Marketing - Airplane Passenger satisfaction Prediction
Description : Using the Survey Data ,Predict whether the Customer will be satisfied or dissatisfied with the services that Airline is providing.¶
- Rows : 90,918
- Columns : 24
Problem Description :¶
This is the dilemma of a reputed US Airline carrier 'Falcon airlines'. They aim to determine the relative importance of each parameter with regards to their contribution to passenger satisfaction. Provided is a random sample of 90,917 indivudiuals who travelled using their Flights . The On-time performance of the flights along with the passenger's information is published in the csv file named 'Flight data'. These passengers were asked to provide their feedback at the end of their flights on various parameters along with their overall experience. These collected details are made available in the survey report csv labelled 'Survey data'.
In the Survey the passengers were explicitly asked whether they were satisfied with their overall flight experience and that is captured in the data of survey report under the variable labelled 'Satisfaction'.
Objectives:¶
- To understand which parameters play an important role in swaying a passenger feedback towards 'satisfied'.
- To predict whether a passenger will be satisfied or not given the rest of the details are provided.
Dataset:¶
The Problem consists of two separate datasets : Flight data and Survey data.
- The Flight data has information related to passengers and the performance of flights in which they travelled.
- The Survey data is the aggregated data of Surveys collected post service experience.
You are expected to treat both the Datasets as raw data and perform any necessary cleaning / validation steps as required.
Introduction¶
Defining Problem Statement :¶
The problem of passenger dissatisfaction has the impact of decreased Airline Passenger numbers, which affects the Aviation business drastically. So, a good starting point would be to analyse the significant attributes as well as predict whether a passenger will be satisfied with the same in future or not.
Need of the Study / Project :¶
The Project / study is primarily aimed at analyzing the key factors driving seamless Customer satisfaction. And Secondly , building a Predictive Model which would cater to the Business needs as to whether a passenger would be satisfied with the services or not.
Understanding business / Social Opportunity :¶
In order to remain competitive ,its essential that the Airlines caters to their passengers efficiently which could otherwise have an impact on the Company's profitability.This study aims at providing clear business Insights pertaining to the attributes that drive passenger satisfaction and secondly come up with a robust predictive model which would predict whether a passenger is likely to be satisfied or not .
Data Report :¶
Understanding how data was collected in terms of time , frequency and methodology.¶
The raw Data provided ,consists of two separate datasets : "Flight data",which contains On-time performance of Flights and Passenger information and "Survey data" which contains passenger's feedback at the end of their flights ,on various parameters along with their Overall experience.
Visual Inspection of data (rows , columns , descriptive details)¶
Import necessary Libraries¶
In [1]:
import pandas as pd #data processing csv file I/O (eg. pd.read_csv)
import numpy as np #Linear algebra
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
from scipy.spatial.distance import cdist
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from scipy.spatial.distance import pdist
from sklearn.metrics import silhouette_score
from yellowbrick.cluster import KElbowVisualizer, SilhouetteVisualizer
from scipy.cluster.hierarchy import dendrogram, linkage,cophenet
from sklearn.cluster import AgglomerativeClustering
import warnings
from scipy.stats import zscore
warnings.filterwarnings('ignore')
pd.set_option("display.max_columns", None)
pd.set_option("display.max_rows", 200)
from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split
from sklearn import metrics
from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.impute import KNNImputer
from sklearn.pipeline import Pipeline, make_pipeline
#libraries to help with model building
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import (
AdaBoostClassifier,
GradientBoostingClassifier,
RandomForestClassifier)
from xgboost import XGBClassifier
from sklearn.ensemble import BaggingClassifier
Load the Dataset¶
In [2]:
airdata=pd.read_csv('AirplaneData.csv')
In [3]:
#Making a Copy of the original data set:
data = airdata.copy()
Visual Inspection of Data¶
Shape of data¶
In [313]:
len(data)
Out[313]:
In [314]:
data.shape
Out[314]:
Observations:
The Data set consists of 90917 observations and 24 Attributes.
Lets look at the Datatype:¶
In [5]:
data.dtypes
Out[5]:
Observation
- Out of 24 dtypes , CustomerId, Age , Flight_Distance, DepartureDelayin_Mins, ArrivalDelayin_Mins are Numeric and rest are Object types.
In [48]:
data.dtypes.value_counts() #Count the Data types
Out[48]:
Glimpse of the Data :¶
In [6]:
data.head()
Out[6]:
Observation
- Column names are inconsistent and need to be formatted.
- Most of the variables look categorical in nature .
- There are visible NaNs in the dataset.
- Customer ID column has unique numbers for each record.
Looking at the data info :¶
In [7]:
data.info()
Observation
- The dataset consists of 24 columns are 90,917 rows.
- There are three distinct data types : Float , int and Object .
- Few of the columns seem to have missing values that need attention.
In [4]:
# find categorical variables
categorical = [var for var in data.columns if data[var].dtype=='O']
print('There are {} categorical variables\n'.format(len(categorical)))
print('The categorical variables are :', categorical)
Checking for Duplicates¶
In [8]:
# lets check duplicate observations
data.duplicated().sum()
Out[8]:
Observation
- There are No Duplicate records in the dataset.
Lets Look at the Summary of the Data:¶
In [2]:
# df.describe() gives us an understanding of the Central tendencies of Data
In [9]:
data.describe(include='all').T
Out[9]:
Observation
- Gender : Female seems to be more prominant than Males.
- Loyal Customers seem to be in majority .
- Average Age is 39 years , while minimum being 7 and maximum being 85.
- Looks like most of the passengers use this Airlines for Business trips.
- The Average Flight distance is 1981.63 kilometers with a standard deviation of 1026.78.
- When it comes to Departure,there is a delay of 14 to 15 mins on an avg and same is the case with Arival delay.
- Looks liks a mojority of passengers have rated a 3 or Acceptable for Seat Comfort.
- Most of them have rated a 4 when it comes to Departure Arrival time convenience.
- Food n Drink services have been rated as Acceptable by a majority.
- For a majority of them the Gate Location seems "Manageable"
- The In-Flight wifi servce as well as In-flight entertainment has been rated a 4 by a greater percentage of passengers.
- All the other sevices like Online support , Ease of Online booking, Onboard Service, Leg Room service , Baggage Handling , Check-in Service , cleanliness , Online boarding have received a 4 star Rating by a majority of them.
In [93]:
print("The average Customer Age {:.4f} years, 50% of Customers are of {} Age or less, while the maximum Customer Age is {}.".format(data['Age'].mean(),data['Age'].quantile(0.50), data['Age'].max()))
In [5]:
# Quick way to separate numeric columns
data.describe().columns
Out[5]:
Understanding of Attributes :¶
Variable Info:¶
- CustomerId : Unique Customer ID of the Passengers
- Gender : Male or Female
- CustomerType : Loyal or Disloyal Customers
- Age : Age of the Customers
- TypeTravel : Business or Personal Travel
- Class : Business , Economy or Economy plus class
- Flight_Distance : Distance from one destination to the other.
- DepartureDelayin_Mins : minutes delayed before Departure.
- ArrivalDelayin_Mins : minutes delayed before Arrival.
- Seat_comfort : In flight Seat comfort ratings by customer.
- Departure.Arrival.time_convenient : customer rating as per their convinience with respect to delay time.
- Food_drink : In-Flight Food and Drink Service ratings.
- Gate_location : Ratings based on the convience level .
- Inflightwifi_service : Wifi service rating on a level of 0 to 5.
- Inflight_entertainment: In Flight entertainment rating on a level of 0 to 5.
- Online_support : pre-boarding online support rating .
- Ease_of_Onlinebooking : Ratings relating to ease of online Flights booking.
- Onboard_service : Ratings on a scale on 0 to 5 .
- Leg_room_service : Leg room service rating on a scale on 0 to 5.
- Baggage_handling : Baggage handling rated on a scale of 0 to 5.
- Checkin_service : Check in services rated on a scale of 0 to 5.
- Cleanliness : Cleanliness rating on a scale of 0 to 5
- Online_boarding : Online Check in rated on a scakle of 0 to 5
- Satisfaction : This is our target variable (satisfied or dissatisfied)
Renaming Columns to make it more understandable:¶
In [4]:
data = data.rename(columns={'CustomerId': 'Customer_Id', 'CustomerType': 'Customer_Type','TypeTravel': 'Travel_Type',
'Class': 'Travel_Class','Departure.Arrival.time_convenient': 'Dep_Arriv_time_convenient',
'Leg_room_service': 'Legroom_service','Inflightwifi_service': 'Inflght_wifi_service',
'Inflight_entertainment': 'Inflght_entrtnmnt',
'Ease_of_Onlinebooking': 'Ease_of_Online_bkng','DepartureDelayin_Mins': 'DeprtDelayin_Mins',
'ArrivalDelayin_Mins': 'ArrivDelayin_Mins'})
Look at the Column names:¶
In [20]:
data.head()
Out[20]:
Observation
- Now the Column names look tidy and consistent.
Lets look at the Unique values in each of the Columns¶
In [316]:
# Lets see unique values
colmns = data.columns
for col in colmns:
print('Unique Values of {} are \n'.format(col),data[col].unique())
print('*'*90)
Observation
- Customer ID column shows all unique Customer IDs.
- Customer Type , Travel Type columns seems to have missing values.
- Numeric Columns seem to show different scales of Data which needs to be standardized.
- All of the Survey columns are Categorical in nature with 5 to 6 unique values in them.
Checking for Missing values :¶
In [317]:
#checking for missing values
data.isna().sum().sort_values(ascending = False)
Out[317]:
Observation
- There are quite a number of columns with missing values .
- We will be examining the data and checking for missing data patterns before we use any missing value imputation.
Percentage of values that are NULL¶
In [318]:
percent = (data.isnull().sum()/len(data)).round(4)*100
print(percent)
Observation
- ArrivDelayin_Mins has the lowest percentage of Nulls.
Looking at the Total Nulls and their corresponding Percentage¶
In [319]:
total = data.isnull().sum().sort_values(ascending=False) # total number of null values
percent = (data.isnull().sum()/data.isnull().count()).sort_values(ascending=False).round(4)*100
missing=pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])
print(missing)
Observation
- Customer_Type has the highest percentage of NULLS.
Converting Object variables to Categories:¶
In [5]:
to_be_cat = ['Gender' , 'Customer_Type' , 'Travel_Class' , 'Travel_Type', 'Seat_comfort', 'Dep_Arriv_time_convenient',
'Food_drink', 'Gate_location', 'Inflght_wifi_service',
'Inflght_entrtnmnt', 'Online_support', 'Ease_of_Online_bkng',
'Onboard_service', 'Legroom_service', 'Baggage_handling',
'Checkin_service', 'Cleanliness', 'Online_boarding', 'Satisfaction']
for col in to_be_cat:
data[col] = data[col].astype('category')
In [8]:
data.info()
Observations
- There are 19 Categorical and 5 Numeric variables after dtype conversion.
Initial Exploratory Data Analysis¶
Uni-variate Analysis - Numeric Features¶
In [556]:
# While doing uni-variate analysis of numerical variables we want to study their central tendency
# and dispersion.
# Let us write a function that will help us create boxplot and histogram for any input numerical
# variable.
# This function takes the numerical column as the input and returns the boxplots
# and histograms for the variable.
# Let us see if this help us write faster and cleaner code.
def histogram_boxplot(feature, figsize=(10, 8), bins=None,xlabelsize=12, ylabelsize=10):
"""Boxplot and histogram combined
feature: 1-d feature array
figsize: size of fig (default (9,8))
bins: number of bins (default None / auto)
"""
f2, (ax_box2, ax_hist2) = plt.subplots(
nrows=2, # Number of rows of the subplot grid= 2
sharex=True, # x-axis will be shared among all subplots
gridspec_kw={"height_ratios": (0.25, 0.75)},
figsize=figsize,
) # creating the 2 subplots
sns.boxplot(
feature, ax=ax_box2, showmeans=True, color="violet"
) # boxplot will be created and a star will indicate the mean value of the column
sns.distplot(
feature, kde=F, ax=ax_hist2, bins=bins, palette="winter"
) if bins else sns.distplot(
feature, kde=False, ax=ax_hist2, color="darkgreen"
) # For histogram
ax_hist2.axvline(
np.mean(feature), color="purple", linestyle="--"
) # Add mean to the histogram
ax_hist2.axvline(
np.median(feature), color="black", linestyle="-"
) # Add median to the histogram
Observations on Customer ID¶
In [557]:
histogram_boxplot(data["Customer_Id"])
Observation
- This variable does not show any specific patterns.
Observations on Age
In [558]:
histogram_boxplot(data["Age"])
In [555]:
sns.distplot(data1['Age'],color='magenta',hist_kws={"color": "darkgreen"})
Out[555]:
Obsevation
- Customer Age does not show any visible outliers.
- The variable is fairly normally distributed with approx equal Mean and Median.
- There is a slight right skew , a few observations seem to lie above the upper quartile.
- Average Age is around 39 - 40 yrs.
Observations on Flight Distance
In [559]:
histogram_boxplot(data["Flight_Distance"])
Observation
- Flight Distance looks slightly Right skewed and there are visible upper Outliers in the boxplot.
- Average Flight Distance is around 2000 Miles .
- Minimum values reaching very low numbers and maximum going beyond 5000 as well.
Observation on Departure Delay in Mins
In [560]:
histogram_boxplot(data["DeprtDelayin_Mins"])
Observation
- This variable is extremely Right skewed with clearly visible upper outliers.
- But are they actually outliers or variation in the values is to be analysed.
- There seems to be a zero or no Departure delay for most of the observations.
Observations on Arrival Delay in Mins
In [561]:
histogram_boxplot(data["ArrivDelayin_Mins"])
Observations
- This variable is extremely Right skewed with clearly visible upper outliers.
- But are they actually outliers or variation in the values is to be analysed.
- There seems to be a zero or no Arrival delay for most of the observations.
Univariate Analysis - Categorical Features¶
In [562]:
# Function to create barplots that indicate percentage for each category.
def perc_on_bar(plot, feature):
"""
plot
feature: categorical feature
the function won't work if a column is passed in hue parameter
"""
total = len(feature) # length of the column
for p in ax.patches:
percentage = "{:.1f}%".format(
100 * p.get_height() / total
) # percentage of each class of the category
x = p.get_x() + p.get_width() / 2 - 0.05 # width of the plot
y = p.get_y() + p.get_height() # hieght of the plot
ax.annotate(percentage, (x, y), size=12) # annotate the percantage
plt.show() # show the plot
Observations on Gender¶
In [567]:
plt.figure(figsize=(6, 5))
ax = sns.countplot(data["Gender"], palette="plasma")
perc_on_bar(ax, data["Gender"])
Observation
- The proportion of Females is slightly greater than the proportion of Males in the dataset.
Observations on Customer Type¶
In [568]:
plt.figure(figsize=(6, 5))
ax = sns.countplot(data["Customer_Type"], palette="plasma")
perc_on_bar(ax, data["Customer_Type"])
Observations
- Loyal Customers clearly outnumber Disloyal Customers.
Observations on Travel type¶
In [569]:
plt.figure(figsize=(6, 5))
ax = sns.countplot(data["Travel_Type"], palette="plasma")
perc_on_bar(ax, data["Travel_Type"])
Observation
- Almost 63% of the Customers seem to be making Business trips rather than Personal.
Observations on Travel Class¶
In [570]:
plt.figure(figsize=(6, 5))
ax = sns.countplot(data["Travel_Class"], palette="plasma")
perc_on_bar(ax, data["Travel_Class"])
Observation
- Business Class Customers are the highest followed by Economy .
- Just about 7.3% Customers belong to Eco Plus Class .
Observations on Seat_comfort¶
In [575]:
plt.figure(figsize=(9, 5))
ax = sns.countplot(data["Seat_comfort"], palette="plasma")
perc_on_bar(ax, data["Seat_comfort"])
Observation
- 16% of the passengers hav rated the Seat Comfort as "Poor"
- Whereas about half the Customers in the Dataset seem satisfied with the Seat Comfort.
Observations on Departure Arrival Time Convenient¶
In [576]:
plt.figure(figsize=(9, 5))
ax = sns.countplot(data["Dep_Arriv_time_convenient"], palette="plasma")
perc_on_bar(ax, data["Dep_Arriv_time_convenient"])
Observation
- Its significant that a good majority of the Passengers have no complaints with regards to the Departure or Arival time .
- Any how there are a small percentage who have rated "Poor" as well as "Extremely Poor"
Observation on Food_drink¶
In [579]:
plt.figure(figsize=(9, 5))
ax = sns.countplot(data["Food_drink"], palette="plasma")
perc_on_bar(ax, data["Food_drink"])
Observation
- There seem to be a good percentage of the passengers who are satisfied with the Food and Drink In-Flight.
- A very small percentage of customers have given a 0 and 1 rating as well.
Observations on Gate_location¶
In [581]:
plt.figure(figsize=(10, 5))
ax = sns.countplot(data["Gate_location"], palette="plasma")
perc_on_bar(ax, data["Gate_location"])
Observation
- About 17 to 18% of the Passengers have rated Gate Location as Inconvenient.
- About 40% of the Customers have given satisfactory rating in terms of manageability.
- There are a few who feel it Needs improvement.
Observations on Inflght_wifi_service¶
In [584]:
plt.figure(figsize=(10, 5))
ax = sns.countplot(data["Inflght_wifi_service"], palette="plasma")
perc_on_bar(ax, data["Inflght_wifi_service"])
Observation
- Just about 11% of the Customers feel the In-Flight wifi service is poor.
- A good percentage of Customers look satisfied with the wi-fi services in flight.
Observation on Inflght Entertainment¶
In [586]:
plt.figure(figsize=(10, 5))
ax = sns.countplot(data["Inflght_entrtnmnt"], palette="plasma")
perc_on_bar(ax, data["Inflght_entrtnmnt"])
Observation
- About 70 - 75% of the passengers seem to have given a satisfacory rating.
- The rest of them feel it needs improvement or poor.
Observations on Online_support¶
In [587]:
plt.figure(figsize=(10, 5))
ax = sns.countplot(data["Online_support"], palette="plasma")
perc_on_bar(ax, data["Online_support"])
Observation
- Its visible from the trend that a majority of the customers seem satisfied with the Online support services.
Observations on Ease_of_Online_bookng¶
In [589]:
plt.figure(figsize=(10, 5))
ax = sns.countplot(data["Ease_of_Online_bkng"], palette="plasma")
perc_on_bar(ax, data["Ease_of_Online_bkng"])
Observation
- More than half of the percentage of Customers seem satisfied with the Ease of Online Bookings.
- Just about 19% of them however seem to have rated "Poor".
Observations on Onboard_service¶
In [590]:
plt.figure(figsize=(10, 5))
ax = sns.countplot(data["Onboard_service"], palette="plasma")
perc_on_bar(ax, data["Onboard_service"])
In [732]:
# Prepare Data
df = data.groupby('Onboard_service').size()
sns.set(palette="Paired")
# Make the plot with pandas
df.plot(kind='pie', subplots=True, figsize=(5, 5))
plt.title("Pie Chart of On-Board Service")
plt.ylabel("")
plt.show()
Observation
- Its significant that a majority of the Customers seem to be satisfied with the Onboard Services.
- Just about 10 - 12% have rated it a 1 or 2 on a scale of 5 , with 5 being the highest.
Observation on Legroom_service¶
In [594]:
plt.figure(figsize=(10, 5))
ax = sns.countplot(data["Legroom_service"], palette="plasma")
perc_on_bar(ax, data["Legroom_service"])
Observation
- About 20% of the Passengers seem to have rated the Leg room Service as Poor or Need Improvement.
- And the Rest of the passengers seem satisfied with the same.
Observation on Baggage_handling¶
In [595]:
plt.figure(figsize=(10, 5))
ax = sns.countplot(data["Baggage_handling"], palette="plasma")
perc_on_bar(ax, data["Baggage_handling"])
Observation
- A good percentage of the Customers have given top ratings in terms of Baggage handling.
- There are anyhow a few who feel the service needs improvement and around 6% feel its Poor.
Observation on Checkin_service¶
In [596]:
plt.figure(figsize=(10, 5))
ax = sns.countplot(data["Checkin_service"], palette="plasma")
perc_on_bar(ax, data["Checkin_service"])
Observation
- About 70 to 75 % of the Customers have given top ratings in terms of Check-in services.
- A few of them feel its Needs improvement .
Observation on Cleanliness¶
In [408]:
plt.figure(figsize=(10, 5))
ax = sns.countplot(data["Cleanliness"], palette="plasma")
perc_on_bar(ax, data["Cleanliness"])
Observation
- More than half of the Customers in the Dataset have given top ratings in terms of Cleanliness In-Flight.
- There are just about 10 - 15% who feel it needs improvement.
Observation on Online_boarding¶
In [597]:
plt.figure(figsize=(10, 5))
ax = sns.countplot(data["Online_boarding"], palette="plasma")
perc_on_bar(ax, data["Online_boarding"])
Observation
- About 60 - 70% of the Customers seem to give a satisfactory rating in terms of Online boarding services.
- There are about 14-15% who feel its poor or needs improvement.
Observation on Satisfaction¶
In [598]:
plt.figure(figsize=(10, 5))
ax = sns.countplot(data["Satisfaction"], palette="plasma")
perc_on_bar(ax, data["Satisfaction"])
In [599]:
freq_table = data["Satisfaction"].value_counts().to_frame()
freq_table.reset_index(inplace=True) # reset index
freq_table.columns = [ "Satisfaction" , "Cnt_Satisfaction"] # rename columns
freq_table["Pecentage"] = freq_table["Cnt_Satisfaction"] / sum(freq_table["Cnt_Satisfaction"])
freq_table
Out[599]:
In [734]:
# Python Pie Chart code with formatting
plt.figure(figsize=(5,5))
#colors = ['turquoise', 'lightcoral']
sns.set(palette="Set2")
explode = (0.1, 0, 0, 0) # explode 1st slice
# Plot
plt.pie(freq_table['Cnt_Satisfaction'],
labels=freq_table['Satisfaction'],
colors=colors,
autopct='%1.1f%%',
shadow=True, startangle=140)
plt.axis('equal')
plt.show()
Observation
- About 54.7% of the Customers are likely to be Satisfied with the Overall flight Services.
- And about 45% of them seem be Neutral of dissatisfied with the same.
Bivariate Analysis - Correlation¶
In [61]:
all_col = data.select_dtypes(include=np.number).columns.tolist()
plt.figure(figsize=(15,7))
sns.heatmap(data[all_col].corr(),
annot=True,
linewidths=0.5,vmin=-1,vmax=1,
center=0,cmap='cividis',
cbar=True,)
plt.show()
Observation
- DeprtDelayin_Mins and ArrivDelayin_Mins seem to show a strong positive Correlation.
A Closer look at the the Correlated variables : DeprtDelayin_Mins and ArrivDelayin_Mins¶
In [36]:
sns.pairplot(data1[['ArrivDelayin_Mins' , 'DeprtDelayin_Mins']])
plt.show()
Observation
- There seem to exist a Strong positive correlation bwetween these variables.
In [601]:
# Listing Categorical variables
categorical_cols=['Gender', 'Customer_Type', 'Travel_Type',
'Travel_Class', 'Seat_comfort', 'Dep_Arriv_time_convenient',
'Food_drink', 'Gate_location', 'Inflght_wifi_service',
'Inflght_entrtnmnt', 'Online_support', 'Ease_of_Online_bkng',
'Onboard_service', 'Legroom_service', 'Baggage_handling',
'Checkin_service', 'Cleanliness', 'Online_boarding']
In [696]:
## Function to plot stacked bar chart
def stacked_plot(x):
sns.set(palette="Set1")
tab1 = pd.crosstab(x, data["Satisfaction"], margins=True)
print(tab1)
print("-" * 120)
tab = pd.crosstab(x, data["Satisfaction"], normalize="index")
tab.plot(kind="bar", stacked=True, figsize=(8, 5))
# plt.legend(loc='lower left', frameon=False)
# plt.legend(loc="upper left", bbox_to_anchor=(0,1))
plt.show()
Gender VS Satisfaction¶
In [697]:
stacked_plot(data["Gender"])
Observation
- Female Customers show a greater likelihood of Satisfaction with the Flight services ,than Males.
Seat Comfort Vs Satisfaction¶
In [698]:
stacked_plot(data["Seat_comfort"])
Obsevation
- There are a good proportion of Customers who seem to have rated the Seat Comfort as Extremely poor , yet likely to be Satisfied with the Other services.
Food and Drink VS Satisfaction¶
In [699]:
stacked_plot(data["Food_drink"])
Observation
- A majority of the Customers who rated Food and Drink Services as Extremely poor are also likely to be classified as satisfied for the fact that there could be other parameters driving them towards satisfied.
Gate Location Vs Satisfaction¶
In [700]:
stacked_plot(data["Gate_location"])
Observation
- A majority of the customers who rated Gate Location as 'Very inconvenient' yet show a likelihood of 'Satisfied'. There could be other parameters driving them towards Satisfied.
Inflight Wi-Fi Vs Satisfaction¶
In [701]:
stacked_plot(data["Inflght_wifi_service"])
Observation
- There seems to be a good percentage of Customers who are happy with the In-Flight wi-fi services and are likely to be classified as 'Satisfied'
Inflight Entertainment VS Satisfaction¶
In [702]:
stacked_plot(data["Inflght_entrtnmnt"])
Observations
- Its significant that a good percentage of the Customers have rated the In-flight Entertainment as "Excellent"
Online Support Vs Satisfaction¶
In [703]:
stacked_plot(data["Online_support"])
Observation
- Its significant that a most of the Customers do not seem to be satisfied with the Online Support.
Ease of Online booking VS Satisfaction¶
In [704]:
stacked_plot(data["Ease_of_Online_bkng"])
Observation
- Its clearly indicated that most of the customers don't seem to be satisfied with the Ease of Online Banking and thats driving them towards 'Neutral' or 'Dissatisfied'
LegRoom Service VS Satisfaction¶
In [705]:
stacked_plot(data["Legroom_service"])
Observation
- Looks like , for the Customers who rated the Legroom Service as 'good' or 'Extremely poor' yet classified under 'Satisfied' ,could be other factors influencing their Satisfaction .
Check-in Service VS Satisfaction¶
In [706]:
stacked_plot(data["Checkin_service"])
Observation
- Clearly there is a negative rating trend with respect to 'Check-in' Service and these are the ones classified as Neutral or Dissatisfied.
Travel Class vs Gender and Age¶
In [718]:
plt.figure(figsize=(10, 5))
sns.boxplot(x='Travel_Class',y='Age',data=data,hue='Gender',palette="RdYlGn")
Out[718]:
Observation
- It is significant from the boxplots that Business class is majorly preferred by both the Genders between with an Avg Age of around 40..
- Most of the others between Age groups 20 and 50 commonly use Economy Class or Eco Plus class for travel.
Customer Type Vs Age and Gender¶
In [30]:
sns.boxplot(x='Customer_Type',y='Age',data=data,hue='Gender')
Out[30]:
Observation
- Both Customers with a Mean Age of 40 show up as Loyal Customers for the Airlines.
- Whereas those below an avg Age of 35 show up as Disloyal Customers.
Customer Type vs Age and Satisfaction¶
In [52]:
plt.figure(figsize=(10, 5))
sns.boxplot(x='Customer_Type',y='Age',data=data,hue='Satisfaction',palette="bright")
Out[52]:
Observation
- The Loyal Customers Avg Age of around 40 yrs are more like to be "Satisfied"
- Disloyal Customers with an Avg Age of 25 yrs are likely to be "Satisfied"
Flight Distance Vs In-flight Wi-fi vs Satisfied¶
In [63]:
plt.figure(figsize=(10, 5))
sns.boxplot(x='Inflght_wifi_service',y='Flight_Distance',data=data,hue='Satisfaction',palette="bright")
Out[63]:
Observation
- The Customers who travel longer distances and who have rated wi-fi Services as Extremely poor also show up as Satisfied .
Gender vs Satisfaction¶
In [731]:
f,ax=plt.subplots(1,2,figsize=(12,7))
sns.set(palette="Paired")
data['Satisfaction'][data['Gender']=='Male'].value_counts().plot.pie(explode=[0,0.2],autopct='%1.1f%%',ax=ax[0],shadow=True)
data['Satisfaction'][data['Gender']=='Female'].value_counts().plot.pie(explode=[0,0.2],autopct='%1.1f%%',ax=ax[1],shadow=True)
ax[0].set_title('Satisfied (Male)')
ax[1].set_title('Satisfied (Female)')
plt.show()
Observation
- 65% Female Customers in the Dataset show a greater likelihood of Satisfaction than the Males.
Compare Satisfaction rate across : 'Age', 'Flight_Distance', 'DepartureDelayin_Mins', 'ArrivalDelayin_Mins'¶
In [7]:
pd.pivot_table(data, index = 'Satisfaction', values= ['Age', 'Flight_Distance', 'DepartureDelayin_Mins', 'ArrivalDelayin_Mins'])
Out[7]:
Observation
- The Avg Age of the Customers who were "Satisfied" is 41.
- The Avg Arrival Delay and Departure Delay is lesser for the Customers who were "Satisfied"
- Data pre-processing
- Removal of unwanted variables
- Missing Value Treatment
- Outlier treatment
- Variable Transformation
- Addition of New variables
Data Preprocessing¶
Creating Another Copy of Dataset : Replacing the new Structure¶
Creating a copy of dataset:¶
In [6]:
data1=data.copy()
Mapping categories with their numeric Ratings :¶
In [7]:
replaceStruct = {
"Seat_comfort": {"extremely poor": 0, "poor": 1 ,"need improvement": 2 ,"acceptable":3, "good":4 , "excellent": 5},
"Dep_Arriv_time_convenient": {"extremely poor": 0, "poor": 1 ,"need improvement": 2 ,"acceptable":3, "good":4 , "excellent": 5},
"Food_drink": {"extremely poor": 0, "poor": 1 ,"need improvement": 2 ,"acceptable":3, "good":4 , "excellent": 5},
"Gate_location": {"very inconvinient": 0, "Inconvinient": 1 ,"need improvement": 2 ,"manageable":3, "Convinient":4 , "very convinient": 5},
"Inflght_wifi_service": {"extremely poor": 0, "poor": 1 ,"need improvement": 2 ,"acceptable":3, "good":4 , "excellent": 5},
"Inflght_entrtnmnt": {"extremely poor": 0, "poor": 1 ,"need improvement": 2 ,"acceptable":3, "good":4 , "excellent": 5},
"Online_support": {"extremely poor": 0, "poor": 1 ,"need improvement": 2 ,"acceptable":3, "good":4 , "excellent": 5},
"Ease_of_Online_bkng": {"extremely poor": 0, "poor": 1 ,"need improvement": 2 ,"acceptable":3, "good":4 , "excellent": 5},
"Onboard_service": {"extremely poor": 0, "poor": 1 ,"need improvement": 2 ,"acceptable":3, "good":4 , "excellent": 5},
"Legroom_service": {"extremely poor": 0, "poor": 1 ,"need improvement": 2 ,"acceptable":3, "good":4 , "excellent": 5},
"Baggage_handling": {"poor": 1 ,"need improvement": 2 ,"acceptable":3, "good":4 , "excellent": 5},
"Checkin_service": {"extremely poor": 0, "poor": 1 ,"need improvement": 2 ,"acceptable":3, "good":4 , "excellent": 5},
"Cleanliness": {"extremely poor": 0, "poor": 1 ,"need improvement": 2 ,"acceptable":3, "good":4 , "excellent": 5},
"Online_boarding": {"extremely poor": 0, "poor": 1 ,"need improvement": 2 ,"acceptable":3, "good":4 , "excellent": 5},
"Satisfaction": {"satisfied": 1, "neutral or dissatisfied": 0 }
}
Replacing the categorical survey columns with the above structure¶
In [8]:
data1=data1.replace(replaceStruct)
In [9]:
data1.head()
Out[9]:
Removal of unwanted variables¶
Dropping the variable "Customer_Id":¶
In [9]:
data.drop('Customer_Id', axis=1, inplace=True)
In [10]:
data.drop('Customer_Type', axis=1, inplace=True)
In [11]:
data1.drop('Customer_Id', axis=1, inplace=True)
In [12]:
data1.drop('Customer_Type', axis=1, inplace=True)
In [14]:
data.shape #Look at the shape of dataset
Out[14]:
In [15]:
data1.shape
Out[15]:
Observation
- We have a total of 90917 observations and 22 dimensions in the dataset.
Missing Value Treatment¶
Lets look at Random sample of Obsevations for Missing Data patterns if any:¶
In [746]:
data1.sample(5)
Out[746]:
Observation
- There are visible NANs in few columns in the Dataset which needs to be treated.
- The Columns DeprtDelayin_Mins and ArrivDelayin_Mins seem to have 0s as well , but those may be the actual values and not missing data,
In [747]:
# number of missing values (only the ones recognised as missing values) in each of the attributes
pd.DataFrame( data1.isnull().sum(), columns= ['Number of missing values'])
Out[747]:
Observation
- The Columns "Dep_Arriv_time_convenient" , "Travel_Type" , "Food_Drink" , "ArrivDelayin_Mins" and "Onboard_service" seem to have Missing values.
In [748]:
data1.isnull().sum().sum() # Total number of recognised missing values in the entire dataframe
Out[748]:
Observation
- We have a total of 32,976 missing values in the Dataset.
Lets Look at the Pattern of Missingness:¶
In [749]:
# most rows don't have missing values now
num_missing = data1.isnull().sum(axis=1)
num_missing.value_counts()
Out[749]:
Travel_Type: Filling Missing Data :Categorical column¶
For the Category Travel_Type : NaNs can be replaced by Economy Class where the Adjacent value of Travel_class is Eco¶
In [751]:
data1[num_missing == 2].head(5)
Out[751]:
We First Replace NaNs with Strings: In column "Travel Type"¶
In [13]:
data1['Travel_Type'] = data1['Travel_Type'].astype(str).replace('nan', 'is_missing').astype('category')
In [16]:
data1['Travel_Type'].value_counts()
Out[16]:
Travel Type becomes Personal Travel if Travel Class is Eco¶
In [14]:
data1.loc[data1.Travel_Class == "Eco", "Travel_Type"] = "Personal Travel"
In [755]:
data1['Travel_Type'].value_counts()
Out[755]:
Travel Type becomes Personal Travel if Travel Class is Eco Plus¶
In [15]:
data1.loc[data1.Travel_Class == "Eco Plus", "Travel_Type"] = "Personal Travel"
In [45]:
data1['Travel_Type'].value_counts()
Out[45]:
Travel Type becomes Business Travel if Travel Class is Business¶
In [16]:
data1.loc[data1.Travel_Class == "Business", "Travel_Type"] = "Business travel"
In [759]:
data1['Travel_Type'].value_counts()
Out[759]:
In [17]:
#Removing "is_missing" category from Travel_Type
data1['Travel_Type'] = data1['Travel_Type'].cat.remove_categories(['is_missing'])
In [18]:
#Checking if the Category is removed
data1['Travel_Type'].value_counts()
Out[18]:
In [19]:
#checking for missing values
data1.isna().sum().sort_values(ascending = False)
Out[19]:
Observation
- We see 0 Missing values for Travel Type. We are now left with Numeric Columns with Missing values.
Outlier Treatment¶
In [18]:
# outlier detection using boxplot
numerical_col = ['Flight_Distance' ]
plt.figure(figsize=(20,30))
for i, variable in enumerate(numerical_col):
plt.subplot(5,4,i+1)
plt.boxplot(data1[variable],whis=1.5)
plt.tight_layout()
plt.title(variable)
plt.show()
In [19]:
def treat_outliers(data1,col):
'''
treats outliers in a varaible
col: str, name of the numerical varaible
df: data frame
col: name of the column
'''
Q1=data1[col].quantile(0.25) # 25th quantile
Q3=data1[col].quantile(0.75) # 75th quantile
IQR=Q3-Q1
Lower_Whisker = Q1 - 1.5*IQR
Upper_Whisker = Q3 + 1.5*IQR
data1[col] = np.clip(data1[col], Lower_Whisker, Upper_Whisker) # all the values samller than Lower_Whisker will be assigned value of Lower_whisker
# and all the values above upper_whishker will be assigned value of upper_Whisker
return data1
def treat_outliers_all(data1, col_list):
'''
treat outlier in all numerical varaibles
col_list: list of numerical varaibles
df: data frame
'''
for c in col_list:
data1 = treat_outliers(data1,c)
return data1
Applying the above function to : 'Flight_Distance','DeprtDelayin_Mins', 'ArrivDelayin_Mins'¶
In [20]:
numerical_col2 =['Flight_Distance']
data1 = treat_outliers_all(data1,numerical_col2)
In [21]:
# Looking at the Boxplot for after treating Outliers
plt.figure(figsize=(20,30))
for i, variable in enumerate(numerical_col2):
plt.subplot(5,4,i+1)
plt.boxplot(data1[variable],whis=1.5)
plt.tight_layout()
plt.title(variable)
plt.show()
Observation
- The Columns are free of Outliers .
Variable Transformation¶
Lets objectively determine if the variable is skewed using Shapiro-Wilks Test.¶
In [26]:
resp = data1.DeprtDelayin_Mins
In [27]:
from scipy.stats import shapiro
In [28]:
shapiro(resp)
Out[28]:
Observation
- Null Hypothesis : The Data somes from a Normal Distribution Sample.
- The P-value is less than 0.05 hence , we shall conclude the data is skewed.
- Hence , we will have to deal with the skewness before we build the Model.
Fisher-Pearson standardized moment coefficient: For Checking Skewness:¶
In [59]:
num_feats=data1.dtypes[data1.dtypes!='object'].index
#Calculate Skew and Sort
skew_feats=data1[num_feats].skew().sort_values(ascending=False)
skewness=pd.DataFrame({'Skew' : skew_feats})
In [60]:
skewness
Out[60]:
Observation
We see that the Columns "DeprtDelayin_Mins" and "ArrivDelayin_Mins" are skewed.
Skewness Treatment¶
Before Log Transformation:¶
In [22]:
# lets plot histogram for Transformed Columns:
from scipy.stats import norm
all_col = ['DeprtDelayin_Mins', 'ArrivDelayin_Mins']
plt.figure(figsize=(15,65))
for i in range(len(all_col)):
plt.subplot(18,3,i+1)
plt.hist(data1[all_col[i]])
#sns.displot(data1[all_col[i]])
plt.tight_layout()
plt.title(all_col[i],fontsize=25)
plt.show()
Applying Log Transformation:¶
In [23]:
for colname in all_col:
data1[colname + '_log'] = np.log(data1[colname]+1)
data1.drop(all_col, axis=1, inplace=True)
After Log Transformation : Reduced Skewness¶
In [63]:
data1.columns
Out[63]:
In [24]:
# lets plot histogram for Transformed Columns:
from scipy.stats import norm
all_col = ['DeprtDelayin_Mins_log', 'ArrivDelayin_Mins_log']
plt.figure(figsize=(15,65))
for i in range(len(all_col)):
plt.subplot(18,3,i+1)
plt.hist(data1[all_col[i]])
#sns.displot(df[all_col[i]], kde=True)
plt.tight_layout()
plt.title(all_col[i],fontsize=25)
plt.show()
Observation
- Skewness is reduced up to some extent.
Pandas Profiling¶
In [191]:
from pandas_profiling import ProfileReport
profile = ProfileReport(data1, minimal=True, title="Pandas Profiling Report")
profile.to_notebook_iframe()
Missing Value Treatment : KNN Imputation for Numeric variables¶
In [25]:
from sklearn.impute import KNNImputer
In [26]:
imputer = KNNImputer(n_neighbors=5)
In [27]:
gender = {'Female':1, 'Male':2}
data1['Gender']=data1['Gender'].map(gender).astype('Int32')
travel_type = {'Personal Travel':1,'Business travel':2}
data1['Travel_Type']=data1['Travel_Type'].map(travel_type).astype('Int32')
travel_class = {'Business':1,'Eco':2, 'Eco Plus':3}
data1['Travel_Class']=data1['Travel_Class'].map(travel_class).astype('Int32')
In [28]:
X = data1
Y = data1["Satisfaction"]
Splitting the Data into Train and Test:¶
In [29]:
# Splitting the data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(
X, Y, test_size=0.30, random_state=1, stratify=Y
)
print(X_train.shape, X_test.shape)
KNN - Missing Value Imputation:¶
In [31]:
#Fit and transform the train data
X_train=pd.DataFrame(imputer.fit_transform(X_train),columns=X_train.columns)
#Transform the test data
X_test=pd.DataFrame(imputer.transform(X_test),columns=X_test.columns)
In [32]:
#Checking that no column has missing values in train or test sets
print(X_train.isna().sum())
print('-'*30)
print(X_test.isna().sum())
Observation
- All missing values have been treated, lets inverse map the encoded values
In [33]:
## Function to inverse the encoding
def inverse_mapping(x,y):
inv_dict = {v: k for k, v in x.items()}
X_train[y] = np.round(X_train[y]).map(inv_dict).astype('category')
X_test[y] = np.round(X_test[y]).map(inv_dict).astype('category')
In [34]:
inverse_mapping(gender,'Gender')
inverse_mapping(travel_type,'Travel_Type')
inverse_mapping(travel_class,'Travel_Class')
Checking Inverse Mapped values or Categories:¶
In [35]:
cols = X_train.select_dtypes(include=['object','category'])
for i in cols.columns:
print(X_train[i].value_counts())
print('*'*30)
In [37]:
cols = X_test.select_dtypes(include=['object','category'])
for i in cols.columns:
print(X_test[i].value_counts())
print('*'*30)
In [36]:
#Converting Float to Int:
to_be_int = ['Age',
'Seat_comfort', 'Dep_Arriv_time_convenient', 'Food_drink',
'Gate_location', 'Inflght_wifi_service', 'Inflght_entrtnmnt',
'Online_support', 'Ease_of_Online_bkng', 'Onboard_service',
'Legroom_service', 'Baggage_handling', 'Checkin_service', 'Cleanliness',
'Online_boarding', 'Satisfaction']
for col in to_be_int:
X_train[col] = X_train[col].astype('int64')
In [37]:
#Converting Float to Int:
to_be_int = ['Age',
'Seat_comfort', 'Dep_Arriv_time_convenient', 'Food_drink',
'Gate_location', 'Inflght_wifi_service', 'Inflght_entrtnmnt',
'Online_support', 'Ease_of_Online_bkng', 'Onboard_service',
'Legroom_service', 'Baggage_handling', 'Checkin_service', 'Cleanliness',
'Online_boarding', 'Satisfaction']
for col in to_be_int:
X_test[col] = X_test[col].astype('int64')
EDA - Post- Data Pre-Processing¶
Creating a Dataframe of Only the Survey Data :¶
In [38]:
data_survey=X_train[['Seat_comfort', 'Dep_Arriv_time_convenient',
'Food_drink', 'Gate_location', 'Inflght_wifi_service',
'Inflght_entrtnmnt', 'Online_support', 'Ease_of_Online_bkng',
'Onboard_service', 'Legroom_service', 'Baggage_handling',
'Checkin_service', 'Cleanliness', 'Online_boarding', 'Satisfaction']]
Lets look at the Target Variable:
In [144]:
X_train.Satisfaction.describe()
Out[144]:
In [146]:
plt.figure(figsize=(6, 5))
plt.hist(X_train.Satisfaction.values, bins=100)
plt.title('Histogram target counts')
plt.xlabel('Count')
plt.ylabel('Satisfaction')
plt.show()
Observation
- This is quite a Balanced Dataset.
Which vaiables are strongly correlated?
In [164]:
plt.figure(figsize=(15, 8))
sns.heatmap(X_train.corr(), annot=True,fmt='.1g')
Out[164]:
Observation
- DepartureDelayin_Mins_log and ArriveDelayin_Mins_log show a strong Positive Correlation.
Number of Unique values per Column in the Dataset:
In [95]:
plt.figure(figsize=(16, 5))
cols = X_train.columns
uniques = [len(X_train[col].unique()) for col in cols]
sns.set(font_scale=1.1)
ax = sns.barplot(cols, uniques, palette='hls', log=True)
ax.set(xlabel='Feature', ylabel='log(unique count)', title='Number of unique per feature')
for p, uniq in zip(ax.patches, uniques):
height = p.get_height()
ax.text(p.get_x()+p.get_width()/2.,
height + 10,
uniq,
ha="center")
ax.set_xticklabels(ax.get_xticklabels(),rotation=90)
plt.show()
Which Column has the Maximum Average percentage of "Satisfaction" rate:
In [96]:
pd.pivot_table(data_survey, index = 'Satisfaction', values= ['Seat_comfort', 'Dep_Arriv_time_convenient',
'Food_drink', 'Gate_location', 'Inflght_wifi_service',
'Inflght_entrtnmnt', 'Online_support', 'Ease_of_Online_bkng',
'Onboard_service', 'Legroom_service', 'Baggage_handling',
'Checkin_service', 'Cleanliness', 'Online_boarding'])
Out[96]:
Observation
In-Flight Entertainment seems to have got the Highest Avg Satisfaction Ratings by the Customers driving them towards Satisfied.
Which Travel Class shows the lowest Avg Satisfaction Rate :
In [97]:
table = pd.pivot_table(data=X_train,index=['Travel_Class'])
table
Out[97]:
Observation
- Economy Class seems to show the Lowest percentage of Avg satisfaction rate.
Which Flight Service has got highest Total overall Rating?
In [98]:
data_survey[['Seat_comfort', 'Dep_Arriv_time_convenient', 'Food_drink',
'Gate_location', 'Inflght_wifi_service', 'Inflght_entrtnmnt',
'Online_support', 'Ease_of_Online_bkng', 'Onboard_service',
'Legroom_service', 'Baggage_handling', 'Checkin_service', 'Cleanliness',
'Online_boarding', 'Satisfaction']].sum()
Out[98]:
In [99]:
#Lets visualise this :
# Created a dataframe to figure out the highest Total Ratings.
total_survey=pd.DataFrame(data_survey.sum(), columns= ['Total'])
In [100]:
my_colors = 'ccccccccccccccg'
total_survey.sort_values(['Total']).plot(kind='bar',figsize=(15,5),color=my_colors)
plt.show()
Observation
- The highest Total Overall Rating is bagged by the In-Flight Service : Cleanliness followed by the Baggage Handling service.
Which Service has got the highest count of Rating : 5
In [101]:
# Creating a Dataset with only 5 Star Ratings:
colmns=data_survey.columns
Rating5=data_survey[data_survey[colmns] == 5]
In [102]:
# Lets look at the value Counts for Ratings : 5 for all Survey variables:
colmns = Rating5.columns
for col in colmns:
print('Value Counts of {} are \n'.format(col),Rating5[col].value_counts())
print('*'*90)
Observation
- The In-Flight Service or the Variable that recieved the highest count of 5 Star Ratings is : "Cleanliness"
Which Service has got the highest count of Rating : 0
In [103]:
# Creating a dataset with only 0 ratings:
colmns=data_survey.columns
Rating0=data_survey[data_survey[colmns] == 0]
In [104]:
# Lets look at the value count for 0 Rating:
colmns = Rating0.columns
for col in colmns:
print('Value Counts of {} are \n'.format(col),Rating0[col].value_counts())
print('*'*90)
Observation
- The variables with Highest Count of 0 Ratings are : Dep_Arriv_time_convenient and Food and Drink.
- The variables with Lowest Count of 0 Ratings are : Baggage Handling and check In Service.
Which Travel Class is preferred by which Age Group and Gender ?
In [105]:
plt.figure(figsize=(15,5))
sns.pointplot(x="Travel_Class", y="Age", hue = 'Gender', data=X_train)
plt.show()
Observation
- Both the genders between Avg Age groups of 41 and 42 mostly travel through Business Class.
- Both the genders between Avg Age groups 37 and 38 mostly travel through Economy Class.
- Both the genders between Avg Age groups 38 and 39 mostly travel through Economy plus Class.
What is the distribution of Ratings in: Baggage Handling
In [106]:
freq_table2 = X_train["Baggage_handling"].value_counts().to_frame()
freq_table2.reset_index(inplace=True) # reset index
freq_table2.columns = [ "Baggage_handling" , "Cnt_Baggage_handling"] # rename columns
freq_table2["Pecentage"] = freq_table2["Cnt_Baggage_handling"] / sum(freq_table2["Cnt_Baggage_handling"])
freq_table2
Out[106]:
In [107]:
# Python Pie Chart code with formatting
plt.figure(figsize=(7,7))
colors = ['dodgerblue', 'blue', 'navy','cornflowerblue','powderblue','silver']
#sns.set(palette="Paired")
explode = (0.1, 0, 0, 0) # explode 1st slice
# Plot
plt.pie(freq_table2['Cnt_Baggage_handling'],
labels=freq_table2['Baggage_handling'],
colors=colors,
autopct='%1.1f%%',
shadow=True, startangle=140)
plt.axis('equal')
plt.show()
Observation
- Its clear that this variable does not show any 0 Ratings , which implies that very few people have complaints regarding Baggage_handling.
Which Travel Type shows higher Satisfaction count :
In [108]:
f,ax=plt.subplots(1,2,figsize=(10,5))
sns.set(palette="muted")
#colors = ['dodgerblue', 'blue', 'navy','cornflowerblue','powderblue','silver']
data1[['Travel_Type','Satisfaction']].groupby(['Travel_Type']).mean().plot.bar(ax=ax[0])
ax[0].set_title('Satisfied vs Travel Type')
sns.countplot('Travel_Type',hue='Satisfaction',data=X_train,ax=ax[1])
ax[1].set_title('Travel Type:Dissatisfied vs Satisfied')
plt.show()
Observation
- The Satisfaction Rate is Higher for Business Travel than for Personal Travel Type.
Departure Delay : Describe
In [109]:
print("The average Customer Departure Delay is {:.2f} minutes, 50% of Records show {:.2f} minutes of Departure Delay or less, while the maximum Delay in Departure is {:.2f} mins."
.format(X_train['DeprtDelayin_Mins_log'].mean(),X_train['DeprtDelayin_Mins_log'].quantile(0.50), X_train['DeprtDelayin_Mins_log'].max()))
Arrival Delay : Describe
In [110]:
print("The average Customer Arrival Delay is {:.2f} minutes, 50% of Records show {:.2f} minutes of Arrival Delay or less,while the maximum Delay in Arrival is {:.2f} mins.".format(X_train['ArrivDelayin_Mins_log'].mean(),X_train['ArrivDelayin_Mins_log'].quantile(0.50), X_train['ArrivDelayin_Mins_log'].max()))
Food N Drink : Describe
In [111]:
print("The average Rating for Food n Drink is {:.0f} stars, 50% of Records show {:.0f} star Rating or lower for Food n Drink , while the maximum Rating is {:.0f} Stars.".format(X_train['Food_drink'].mean(),X_train['Food_drink'].quantile(0.50), X_train['Food_drink'].max()))
OnBoard Service : Describe
In [112]:
print("The average Rating for Onboard_service is {:.0f} stars, 50% of Records show {:.0f} star Rating or lower for Onboard_service , while the maximum Rating is {:.0f} Stars.".format(X_train['Onboard_service'].mean(),X_train['Onboard_service'].quantile(0.50), X_train['Onboard_service'].max()))
What is the Cumulative Percentage Contribution of Services towards Satisfaction:
In [113]:
mydata=pd.read_excel('survey_percentage.xlsx')
In [114]:
mydata.head()
Out[114]:
In [115]:
def pareto_plot(df, x=None, y=None, title=None, show_pct_y=False, pct_format='{0:.0%}'):
xlabel = x
ylabel = y
tmp = df.sort_values(y, ascending=False)
x = tmp[x].values
y = tmp[y].values
weights = y / y.sum()
cumsum = weights.cumsum()
fig, ax1 = plt.subplots(figsize=(25,10))
ax1.bar(x, y)
ax1.set_xlabel(xlabel,size=20)
ax1.set_ylabel(ylabel,size=20)
ax2 = ax1.twinx()
ax2.plot(x, cumsum, '-ro', alpha=0.5)
ax2.set_ylabel('', color='r',size=20)
ax2.tick_params('y', colors='r',size=20)
vals = ax2.get_yticks()
ax2.set_yticklabels(['{:,.2%}'.format(x) for x in vals])
# hide y-labels on right side
if not show_pct_y:
ax2.set_yticks([])
formatted_weights = [pct_format.format(x) for x in cumsum]
for i, txt in enumerate(formatted_weights):
ax2.annotate(txt, (x[i], cumsum[i]), fontweight='bold',size=24)
if title:
plt.title(title)
plt.tight_layout()
plt.show()
In [116]:
pareto_plot(mydata, x='Index', y='Satisfaction_1', title='Rating Trend')
Observation
- Inflght_entrtnmnt , Baggage_handling, Cleanliness ,Ease_of_Online_bkng ,Online_support, Legroom_service are the Services which contribute to almost 50% of the Satisfaction rate.
What is the Average Satisfaction Rate grouped by Customer Age ?
In [131]:
#Creating Subset with only Satisfaction : 1
Satisfaction1 = X_train.loc[X_train.Satisfaction == 1]
In [143]:
Satisfaction1.groupby(["Age"])['Satisfaction'].sum().reset_index().T
Out[143]:
Observation
- The Sum of Satisfaction Rate is higher for Customers between Age groups 39 and 50.
Creating bins for variable : AGE¶
In [207]:
Age_bin= X_train.copy()
In [208]:
Age_bin['Age_bin'] = pd.cut(
Age_bin['Age'], [-np.inf, 11, 31, 51, np.inf],
labels = ["Under 10", "upto 30", "31 to 50'", "Above 50"]
)
Age_bin.drop(['Age'], axis=1, inplace=True)
Age_bin['Age_bin'].value_counts(dropna=False)
Out[208]:
What Age Group is more likely to be Satisfied ?
In [211]:
tab1 = pd.crosstab(Age_bin.Satisfaction,Age_bin.Age_bin,margins=True)
print(tab1)
print('-'*120)
tab = pd.crosstab(Age_bin.Satisfaction,Age_bin.Age_bin,normalize='index')
tab.plot(kind='bar',stacked=True,figsize=(8,6))
plt.legend(loc="upper left", bbox_to_anchor=(1,1));
Observation
- Customers between Ages 30 and 50 are more likely to be Satisfied.
- On the other hand, passengers below 10 yrs are least likely to be satisfied.
What Age Group is more likely to be Satisfied ?
In [233]:
Agegroup = Satisfaction1.groupby(by=['Age'], as_index=False)['Satisfaction'].count()
plt.subplots(figsize=(15,6))
plt.plot(Agegroup.Age, Agegroup.Satisfaction)
plt.xlabel('Customer Age')
plt.ylabel('Satisfaction count')
plt.title('Satisfaction Rate by different Age Group')
plt.show()
Observation
- Customers between Ages 30 and 50 are more likely to be Satisfied.
- On the other hand, passengers below 20 and 60 yrs are least likely to be satisfied.
Which are the TOP 5 Services most likely to sway the Customers towards Satisfaction ?
In [236]:
print('The TOP 5 Services most likely to sway the Customers towards Satisfaction...')
mydata.sort_values(by='Satisfaction_1', ascending=False).head()
Out[236]:
Which Services have not recieved 0 Ratings ?
In [272]:
data_survey.apply(np.min)
Out[272]:
Observation
- Online_support , Baggage_handling , Checkin_service has not been Rated 0 by any of the Customers in the Dataset.
Which Travel Class shows highest Avg Satisfaction Rate ?
In [297]:
X_train.groupby(["Travel_Class"])["Satisfaction"].agg([np.mean]).sort_values(by="mean", ascending=False).T
Out[297]:
Observation
- Business Class shows the highest Avg Satisfaction Rate.
Which Travel Class shows greater likelihood of Satisfaction with respect to Flight Distance and Age of PAssengers?
In [318]:
sns.relplot(x="Age", y="Flight_Distance", hue="Satisfaction",
col="Travel_Class", data=X_train).set_xticklabels(rotation=30);
Observation
- Travel Class : Business : Clearly Business Class shows more of green Datapoints, which implies higher satisfaction rate .
- Travel Class: Economy : Economy Class seems to show more of Dissatisfaction datapoints, which becomes even more clustered as the Age increases.
- Travel Class: Eco Plus : There are comparatively lesser datapoints with almost equat Green and Blue dots.
Which Travel Class shows greater likelihood of Satisfaction with respect to Flight Distance and Arrival Delay?
In [320]:
sns.relplot(x="Flight_Distance", y="ArrivDelayin_Mins_log", hue="Satisfaction",
col="Travel_Class", data=X_train).set_xticklabels(rotation=30);
Observation
- Travel Class : Business : Clearly Business Class shows more of green Datapoints, which implies higher satisfaction rate .
- Travel Class: Economy : Economy Class seems to show more of Dissatisfaction datapoints, which becomes even more clustered as the Flight Distance increases.
- Travel Class : Eco Plus : For Smaller Flight Distances there are lesser Dissatisfaction points.
Encoding Categorical Variables: Addition of New variables¶
In [39]:
X_train=pd.get_dummies(X_train)
X_test=pd.get_dummies(X_test)
print(X_train.shape, X_test.shape)
In [40]:
X_train.head(2)
Out[40]:
In [41]:
X_test.head(2)
Out[41]:
In [42]:
X_train.columns
Out[42]:
In [43]:
X_test.columns
Out[43]:
Observation
- After we Encoded the Categorical variables , now we have a total of 23 Variables in the Train and Test sets.
Analytical Approach : Plan of Action for Model Building : Classification¶
- We gathered all the relevant parameters from the Raw data provided to us.
- Identified the Independent and Dependent Variables.
- We ran through the Descriptive statistics and noted the Observations.
- We ran through the Exploratory Data Analysis to gain insights .
- Data Pre-Processing was done , which included Feature engineering , Missing value imputation, Outlier Treatment, Variable Transformation and Addition of New variables. Thus, making the Data ready for Predictive Analysis.
Objective of the Project :¶
- To understand which parameters play an important role in swaying a passenger feedback towards 'satisfied'.
- To predict whether a passenger will be satisfied or not given the rest of the details are provided.
Alternate Analytical Approach to Solving the problem:¶
- Since the Data we have with us is Labeled data and also we have a Dependent variable , we understand that its Supervised Learning.
- Since the Dependent / Target / Output variable is Binary in nature , we need to follow a Classification Model Building approach.
THE Model building PLAN :¶
- Decide the Model Evaluation Criterion .
- Model Building : Logistic Regression .
- Evaluate the Model using K Fold and Cross Validation Score with Original Imbalanced Classes.
- Build a Confusion Matrix Compare the Evaluation Scores on the Test Set.
- Check For the Optimal Threshold and Apply a higher Cut Off.
- Evaluate the Results through Confusion Matrix.
- Check For the Best Threshold and Apply an Equal or a higher Cut Off.
- Evaluate the Results through Confusion Matrix.
- Evaluate the Model using K Fold and Cross Validation Score with Balanced Classes.
- Compare the Results from all the Logistic Regression Models and Select the Best Model.
- Get the coefficients from the Best Model and Interpret the Results.
- Build Ensemble :Random Forest , Gradient Boost , Bagging Classifier , Adaboost , XGB and Decision Tree.
- Plot the Box plots for the CV Scores for all the Ensemble Models.
- Hypertuning the Models with Grid Search and Random Search.
- Decision Tree with Grid Search CV and Random Search CV.
- Build a Confusion Matrix Compare the Evaluation Scores on the Test Set.
- Random Forest with Grid Search CV and Random Search CV.
- Build a Confusion Matrix Compare the Evaluation Scores on the Test Set.
- Ada Boost with Grid Search CV and Random Search CV.
- Gradient Boost with Grid Search CV and Random Search CV.
- Build a Confusion Matrix Compare the Evaluation Scores on the Test Set.
- XG Boost with Grid Search CV and Random Search CV.
- Build a Confusion Matrix Compare the Evaluation Scores on the Test Set.
- Comparing all the Models so as to check which Model gives us the Best Evaluation Score and
is able to generalise well on the unseen data. - Getting the Feature Importance for the Best Model.
- Build Partial Density Plots for the Important Features and understand their impact on Response variable.
- Lastly , Business Recommendations and Actionable Insights based on our EDA as well as Model Results.
MODELLING PROCESS (validation and Interpretation)¶
Dropping Response Variable from Train and Test¶
In [44]:
X_train.drop('Satisfaction', axis=1, inplace=True)
In [45]:
X_test.drop('Satisfaction', axis=1, inplace=True)
In [46]:
X_train.shape
Out[46]:
In [47]:
X_test.shape
Out[47]:
Model Evaluation Critera¶
True Positives:
Reality: A customer is Satisfied. Model predicted: The customer is likely to be Satisfied. Outcome: The model is good.
True Negatives:
Reality: A customer is Dissatisfied. Model predicted: The customer will be Dissatisfied. Outcome: The business is unaffected.
False Positives:
Reality: A customer was Dissatisfied. Model predicted: The customer will be Satisfied. Outcome: The team which is targeting the potential customers will be wasting their resources on the people/customers who will not be contributing to the revenue.
False Negatives:
Reality: A customer is likely to be Satisfied. Model predicted: The customer will be Dissatisfied. Outcome: The potential customer is missed by the sales/marketing team ,hence affecting the business.
In this case, not being able to identify a potential customer is the biggest loss we can face. Hence, RECALL is the right metric to check the performance of the model.
Satisfied Customer (Class : 1)
Dissatisfied / Neutal Customer (Class : 0)
We are defining a function to print all the Accuracies:¶
In [48]:
## Function to calculate different metric scores of the model - Accuracy, Recall and Precision
def get_metrics_score(model,train,test,train_y,test_y,flag=True):
'''
model : classifier to predict values of X
'''
# defining an empty list to store train and test results
score_list=[]
pred_train = model.predict(train)
pred_test = model.predict(test)
train_acc = model.score(train,train_y)
test_acc = model.score(test,test_y)
train_recall = metrics.recall_score(train_y,pred_train)
test_recall = metrics.recall_score(test_y,pred_test)
train_precision = metrics.precision_score(train_y,pred_train)
test_precision = metrics.precision_score(test_y,pred_test)
score_list.extend((train_acc,test_acc,train_recall,test_recall,train_precision,test_precision))
# If the flag is set to True then only the following print statements will be dispayed. The default value is set to True.
if flag == True:
print("Accuracy on training set : ",model.score(train,train_y))
print("Accuracy on test set : ",model.score(test,test_y))
print("Recall on training set : ",metrics.recall_score(train_y,pred_train))
print("Recall on test set : ",metrics.recall_score(test_y,pred_test))
print("Precision on training set : ",metrics.precision_score(train_y,pred_train))
print("Precision on test set : ",metrics.precision_score(test_y,pred_test))
return score_list # returning the list with train and test scores
We are defining a Function to build the Confusion matrix:¶
In [49]:
def make_confusion_matrix(y_actual,model,labels=[1, 0]):
'''
model : classifier to predict values of X
y_actual : ground truth
'''
y_predict = model.predict(X_test)
cm=metrics.confusion_matrix( y_actual, y_predict, labels=[1, 0])
df_cm = pd.DataFrame(cm, index = [i for i in ["Satisfied","Dissatisfied"]],
columns = [i for i in ['Satisfied','Dissatisfied']])
group_counts = ["{0:0.0f}".format(value) for value in
cm.flatten()]
group_percentages = ["{0:.2%}".format(value) for value in
cm.flatten()/np.sum(cm)]
labels = [f"{v1}\n{v2}" for v1, v2 in
zip(group_counts,group_percentages)]
labels = np.asarray(labels).reshape(2,2)
plt.figure(figsize = (10,7))
sns.heatmap(df_cm, annot=labels,fmt='')
plt.ylabel('True label')
plt.xlabel('Predicted label')
In [50]:
X_train.dtypes
Out[50]:
Lets Check for Multicollinearity¶
In [51]:
from statsmodels.stats.outliers_influence import variance_inflation_factor
In [52]:
# dataframe with numerical column only
num_feature_set = X_train.select_dtypes(include=['int64','float64'])
from statsmodels.tools.tools import add_constant
num_feature_set = add_constant(num_feature_set)
In [53]:
vif_series1 = pd.Series([variance_inflation_factor(num_feature_set.values,i) for i in range(num_feature_set.shape[1])],index=num_feature_set.columns)
print('Series before feature selection: \n\n{}\n'.format(vif_series1))
Observation¶
We do not see any high VIF Scores. Hence, no visible Multicollinearity.
LOGISTIC REGRESSION¶
In [54]:
lr = LogisticRegression(random_state=1)
lr.fit(X_train,y_train)
Out[54]:
Let's evaluate the model performance by using KFold and cross_val_score¶
In [55]:
scoring='recall'
kfold=StratifiedKFold(n_splits=5,shuffle=True,random_state=1) #Setting number of splits equal to 5
cv_result_bfr=cross_val_score(estimator=lr, X=X_train, y=y_train, scoring=scoring, cv=kfold)
#Plotting boxplots for CV scores of model defined above
plt.boxplot(cv_result_bfr)
plt.show()
Observation:
- If u look at the Box plot , the RECALL score seems to be ranging from 84.4 to 84.6.
- This implies that the performance on Training set varies between 84.4 to 84.6 for Recall.
Check the Scores on the TEST Set:¶
In [56]:
#Calculating different metrics
scores_LR = get_metrics_score(lr,X_train,X_test,y_train,y_test)
# creating confusion matrix
make_confusion_matrix(y_test,lr)
Observation¶
- Percentage of the Customers we Predicted as Satisfied and were Actually TRUE = 46.28 % (True Positive)
- Percentage of the Customers we Predicted as Satisfied and were Actually FALSE = 12.14 % (False Positive)
- Percentage of the Customers we Predicted as Dissatisfied and were Actually FALSE = 33.13 % (True Negative)
- Percentage of the Customers we Predicted as Dissatisfied and were Actually TRUE = 8.45 % (False Nagetive)
Observation on Scores
- The Recall score is just 84.5 , which could be improved .
- Logistic Regression has given a generalized performance on training and test set.
- We will try to adjust the Threshold and try again, to see if we get a better score.
Listing the Probabilities on Test Set:¶
In [57]:
lr.predict_proba(X_test)
Out[57]:
AUC and ROC Curve :¶
In [58]:
#AUC ROC curve
from sklearn.metrics import roc_auc_score
from sklearn.metrics import roc_curve
logit_roc_auc = roc_auc_score(y_test, lr.predict_proba(X_test)[:,1])
fpr, tpr, thresholds = roc_curve(y_test, lr.predict_proba(X_test)[:,1])
plt.figure(figsize=(10,8))
plt.plot(fpr, tpr, label='Logistic Regression (area = %0.2f)' % logit_roc_auc)
plt.plot([0, 1], [0, 1],'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.savefig('Log_ROC')
plt.show()
Observation
- Logistic Regression AUC - That is the Area under the Curve is 0.87
- This Curve is going to help us identify the best Threshold to make the Decision.
Lets find out at which point the FPR and TPR difference is highest:¶
In [59]:
# The optimal cut off would be where tpr is high and fpr is low
fpr, tpr, thresholds = roc_curve(y_test, lr.predict_proba(X_test)[:,1])
optimal_idx = np.argmax(tpr - fpr)
optimal_threshold = thresholds[optimal_idx]
print(optimal_threshold)
Observation
- The Optimal threshold right now is : 0.57
In [158]:
def make_confusion_matrix(y_actual,y_predict,labels=[1, 0]):
'''
model : classifier to predict values of X
y_actual : ground truth
'''
#y_predict = model.predict(X_test)
cm=metrics.confusion_matrix( y_actual, y_predict, labels=[1, 0])
df_cm = pd.DataFrame(cm, index = [i for i in ["Satisfied","Dissatisfied"]],
columns = [i for i in ['Satisfied','Dissatisfied']])
group_counts = ["{0:0.0f}".format(value) for value in
cm.flatten()]
group_percentages = ["{0:.2%}".format(value) for value in
cm.flatten()/np.sum(cm)]
labels = [f"{v1}\n{v2}" for v1, v2 in
zip(group_counts,group_percentages)]
labels = np.asarray(labels).reshape(2,2)
plt.figure(figsize = (10,7))
sns.heatmap(df_cm, annot=labels,fmt='')
plt.ylabel('True label')
plt.xlabel('Predicted label')
Lets increase the Threshold greater than Optimal threshold and try again¶
In [61]:
target_names = ['Dissatisfied', 'Satisfied']
y_pred_tr = (lr.predict_proba(X_train)[:,1]>optimal_threshold).astype(int)
y_pred_ts = (lr.predict_proba(X_test)[:,1]>optimal_threshold).astype(int)
In [62]:
make_confusion_matrix(y_test,y_pred_ts)
Observation
- After increasing the Threshold , True Positives decreased from 46.25% to 43.26%
In [63]:
print("Accuracy on training set : ",metrics.accuracy_score(y_train,y_pred_tr))
print("Accuracy on test set : ",metrics.accuracy_score(y_test,y_pred_ts))
print("Recall on training set : ",metrics.recall_score(y_train,y_pred_tr))
print("Recall on test set : ",metrics.recall_score(y_test,y_pred_ts))
print("Precision on training set : ",metrics.precision_score(y_train,y_pred_tr))
print("Precision on test set : ",metrics.precision_score(y_test,y_pred_ts))
Observation
- The Recall Score has decreased from 84.5% to 79% after applying a higher cut off.
Faster approach for finding the optimal threshold¶
In [159]:
y_proba=lr.predict_proba(X_test)[:,1]
In [160]:
from sklearn.metrics import roc_curve, precision_recall_curve
def threshold_search(y_test,y_proba, plot=False):
precision, recall, thresholds = precision_recall_curve(y_test, y_proba)
thresholds = np.append(thresholds, 1.001)
F = 2 / (1/precision + 1/recall)
best_score = np.max(F)
best_th = thresholds[np.argmax(F)]
if plot:
plt.plot(thresholds, F, '-b')
plt.plot([best_th], [best_score], '*r')
plt.show()
search_result = {'threshold': best_th , 'f1': best_score}
return search_result
In [161]:
threshold_search(y_test,y_proba)
Out[161]:
Lets use the above Threshold and try again:¶
In [162]:
threshold=0.5127350164199415
In [163]:
target_names = ['Dissatisfied', 'Satisfied']
y_pred_tr = (lr.predict_proba(X_train)[:,1]>=threshold).astype(int)
y_pred_ts = (lr.predict_proba(X_test)[:,1]>=threshold).astype(int)
In [164]:
make_confusion_matrix(y_test,y_pred_ts)
In [165]:
print("Accuracy on training set : ",metrics.accuracy_score(y_train,y_pred_tr))
print("Accuracy on test set : ",metrics.accuracy_score(y_test,y_pred_ts))
print("Recall on training set : ",metrics.recall_score(y_train,y_pred_tr))
print("Recall on test set : ",metrics.recall_score(y_test,y_pred_ts))
print("Precision on training set : ",metrics.precision_score(y_train,y_pred_tr))
print("Precision on test set : ",metrics.precision_score(y_test,y_pred_ts))
Observation
- The Recall has increased drastically from 79% to 83.9%. And there is no Overfitting as well.
- The Logistic Regression Model with the Best Threshold gave us quite a generalized model .
Finding the Coefficents :¶
Since the Original Logistic Regression Model with Optimum Threshold gave us the best RECALL Score , Lets interpret the Coeffs for the Same:
In [166]:
log_odds = lr.coef_[0]
pd.DataFrame(log_odds, X_train.columns, columns=['coef']).T
Out[166]:
Converting the Coeffs into Odds :¶
In [167]:
odds = np.exp(lr.coef_[0])-1
pd.set_option('display.max_rows',None)
pd.DataFrame(odds, X_train.columns, columns=['odds']).T
Out[167]:
Interpretation From the Coefficients:¶
- Customer_Age : For a one-unit change in Age of Customer , there would be a 0.02% decrease in the odds of a Customer likely to be Satisfied.
- Flight_Distance : For a one-unit change in Flight Distance , there would be a 0.0004% decrease in the odds of a Customer likely to be Satisfied.
- Seat Comfort : For a one-unit change in Seat Comfort Ratings , there would be a 0.21% increase in the odds of a - Customer likely to be Satisfied.
- Dep_Arriv_time_convenient : For a one-unit change in this variable , there would be a 0.009% decrease in the odds of a Customer likely to be Satisfied.
- Food Drink : For a one-unit change in Food Drink Ratings , there would be a 0.19% decrease in the odds of a Customer likely to be Satisfied.
- Gate Location : For a one-unit change in Gate Location , there would be a 0.08% decrease in the odds of a Customer likely to be Satisfied.
- InFlight Wifi Service : For a one-unit change in In-Flight Wifi Rating , there would be a 0.2% decrease in the odds of a Customer likely to be Satisfied.
- InFlight Entertainment : For a one-unit change in the Ratings , there would be a 0.8% increase in the odds of a Customer likely to be Satisfied.
- Online Support : For a one-unit change in the service , there would be a 0.08% increase in the odds of a Customer likely to be Satisfied.
- Ease Of Online Booking : For a one-unit change in Sefrvice , there would be a 0.5% increase in the odds of a Customer likely to be Satisfied.
- OnBoard Sevice : For a one-unit change in Service , there would be a 0.2% increase in the odds of a Customer likely to be Satisfied.
- LegRoom Service : For a one-unit change in Service , there would be a 0.1% increase in the odds of a Customer likely to be Satisfied.
- Baggege Handling : For a one-unit change in Rating , there would be a 0.1% decrease in the odds of a Customer likely to be Satisfied.
- Check-In service : For a one-unit change in Service , there would be a 0.07% increase in the odds of a Customer likely to be Satisfied.
- Cleanliness : For a one-unit change in Service , there would be a 0.1% decrease in the odds of a Customer likely to be Satisfied.
- Online Boarding : For a one-unit change in Service , there would be a 0.02% increase in the odds of a Customer likely to be Satisfied.
- Depart_delay_mins : For a one-unit change in Service , there would be a 0.0% decrease in the odds of a Customer likely to be Satisfied.
- Arriv_delay_mins : For a one-unit change in Service , there would be a 0.1% decrease in the odds of a Customer likely to be Satisfied.
- Gender Female : For a one-unit change in the Gender , there would be a 0.14% increase in the odds of a Customer likely to be Satisfied.
- Gender Male : For a one-unit change in the Gender , there would be a 0.3% decrease in the odds of a Customer likely to be Satisfied.
- Gender Female : For a one-unit change in the Gender , there would be a 0.14% increase in the odds of a Customer likely to be Satisfied.
- Travel_Type_Business travel : For a one-unit change in Travel Type , there would be a 0.2% increase in the odds of a Customer likely to be Satisfied.
- Travel_Type_Personal travel : For a one-unit change in Travel Type , there would be a 0.4% decrease in the odds of a Customer likely to be Satisfied.
- Travel class Business : For a one-unit change in Travel class , there would be a 0.2% increase in the odds of a Customer likely to be Satisfied.
- Travel class Eco : For a one-unit change in Travel Class , there would be a 0.3% decrease in the odds of a Customer likely to be Satisfied.
- Travel class Eco Plus : For a one-unit change in Travel Class , there would be a 0.07% decrease in the odds of a Customer likely to be Satisfied.
Visualizing the Log Odds From Logistic Regression:¶
In [189]:
data = np.array([-0.02,-0.00, 0.21, -0.097 , -0.19, -0.08, -0.23, 0.82, 0.08, 0.58, 0.25, 0.13, -0.10, 0.07 ,-0.13, 0.02, -0.00, -0.15, 0.14, -0.37, 0.27, -0.43, 0.27, -0.38, -0.07])
labels = ['Age', 'Flight_Distance','Seat_comfort','Dep_Arriv_time_convenient','Food_drink','Gate_location','Inflght_wifi_service','Inflght_entrtnmnt','Online_support','Ease_of_Online_bkng','Onboard_service','Legroom_service','Baggage_handling','Checkin_service','Cleanliness','Online_boarding','DeprtDelayin_Mins_log','ArrivDelayin_Mins_log','Gender_Female','Gender_Male','Travel_Type_Business travel','Travel_Type_Personal Travel','Travel_Class_Business','Travel_Class_Eco','Travel_Class_Eco Plus']
import matplotlib.pylab as pl
pl.figure(figsize=(30, 5))
ax=pl.subplot(122)
pl.bar(np.arange(data.size), data)
ax.set_xticks(np.arange(data.size))
ax.set_xticklabels(labels)
ax.set_xticklabels(labels, rotation = 45, ha="right")
Out[189]:
ENSEMBLE MODELS: Model building - Bagging and Boosting¶
In [71]:
models = [] # Empty list to store all the models
# Appending pipelines for each model into the list
models.append(
(
"RF",
Pipeline(
steps=[
("scaler", StandardScaler()),
("random_forest", RandomForestClassifier(random_state=1)),
]
),
)
)
models.append(
(
"GBM",
Pipeline(
steps=[
("scaler", StandardScaler()),
("gradient_boosting", GradientBoostingClassifier(random_state=1)),
]
),
)
)
models.append(
(
"BG",
Pipeline(
steps=[
("scaler", StandardScaler()),
("bagging", BaggingClassifier(random_state=1)),
]
),
)
)
models.append(
(
"ADB",
Pipeline(
steps=[
("scaler", StandardScaler()),
("adaboost", AdaBoostClassifier(random_state=1)),
]
),
)
)
models.append(
(
"XGB",
Pipeline(
steps=[
("scaler", StandardScaler()),
("xgboost", XGBClassifier(random_state=1,eval_metric='logloss')),
]
),
)
)
models.append(
(
"DTREE",
Pipeline(
steps=[
("scaler", StandardScaler()),
("decision_tree", DecisionTreeClassifier(random_state=1)),
]
),
)
)
results = [] # Empty list to store all model's CV scores
names = [] # Empty list to store name of the models
# loop through all models to get the mean cross validated score
for name, model in models:
scoring = "recall"
kfold = StratifiedKFold(
n_splits=5, shuffle=True, random_state=1
) # Setting number of splits equal to 5
cv_result = cross_val_score(
estimator=model, X=X_train, y=y_train, scoring=scoring, cv=kfold
)
results.append(cv_result)
names.append(name)
print("{}: {}".format(name, cv_result.mean() * 100))
In [72]:
# Plotting boxplots for CV scores of all models defined above
fig = plt.figure(figsize=(10, 7))
fig.suptitle("Algorithm Comparison")
ax = fig.add_subplot(111)
plt.boxplot(results)
ax.set_xticklabels(names)
plt.show()
Observation
We can see that XGB (XG-Boost) has given the highest CV Score of 94.4%.
Hyperparameter tuning using grid search AND Random Search¶
In [73]:
## Function to calculate different metric scores of the model - Accuracy, Recall and Precision
def get_metrics_score(model, flag=True):
"""
model : classifier to predict values of X
"""
# defining an empty list to store train and test results
score_list = []
pred_train = model.predict(X_train)
pred_test = model.predict(X_test)
train_acc = model.score(X_train, y_train)
test_acc = model.score(X_test, y_test)
train_recall = metrics.recall_score(y_train, pred_train)
test_recall = metrics.recall_score(y_test, pred_test)
train_precision = metrics.precision_score(y_train, pred_train)
test_precision = metrics.precision_score(y_test, pred_test)
score_list.extend(
(
train_acc,
test_acc,
train_recall,
test_recall,
train_precision,
test_precision,
)
)
# If the flag is set to True then only the following print statements will be dispayed. The default value is set to True.
if flag == True:
print("Accuracy on training set : ", model.score(X_train, y_train))
print("Accuracy on test set : ", model.score(X_test, y_test))
print("Recall on training set : ", metrics.recall_score(y_train, pred_train))
print("Recall on test set : ", metrics.recall_score(y_test, pred_test))
print(
"Precision on training set : ", metrics.precision_score(y_train, pred_train)
)
print("Precision on test set : ", metrics.precision_score(y_test, pred_test))
return score_list # returning the list with train and test scores
In [74]:
def make_confusion_matrix(y_actual,model,labels=[1, 0]):
'''
model : classifier to predict values of X
y_actual : ground truth
'''
y_predict = model.predict(X_test)
cm=metrics.confusion_matrix( y_actual, y_predict, labels=[1, 0])
df_cm = pd.DataFrame(cm, index = [i for i in ["Satisfied","Dissatisfied"]],
columns = [i for i in ['Satisfied','Dissatisfied']])
group_counts = ["{0:0.0f}".format(value) for value in
cm.flatten()]
group_percentages = ["{0:.2%}".format(value) for value in
cm.flatten()/np.sum(cm)]
labels = [f"{v1}\n{v2}" for v1, v2 in
zip(group_counts,group_percentages)]
labels = np.asarray(labels).reshape(2,2)
plt.figure(figsize = (10,7))
sns.heatmap(df_cm, annot=labels,fmt='')
plt.ylabel('True label')
plt.xlabel('Predicted label')
DECISION TREE - GRID SEARCH¶
In [75]:
# Creating pipeline
pipe = make_pipeline(StandardScaler(), DecisionTreeClassifier(class_weight={0:0.45,1:0.55},random_state=1))
# Parameter grid to pass in GridSearchCV
param_grid = {
"decisiontreeclassifier__criterion": ['gini','entropy'],
"decisiontreeclassifier__max_depth": [3, 4, 5, None],
"decisiontreeclassifier__min_samples_split": [2,4,7,10,15]
}
# Type of scoring used to compare parameter combinations
scorer = metrics.make_scorer(metrics.recall_score)
# Calling GridSearchCV
grid_cv = GridSearchCV(estimator=pipe, param_grid=param_grid, scoring=scorer, cv=5)
# Fitting parameters in GridSeachCV
grid_cv.fit(X_train, y_train)
print(
"Best Parameters:{} \nScore: {}".format(grid_cv.best_params_, grid_cv.best_score_)
)
In [76]:
# Creating new pipeline with best parameters
dtree_tuned1 = make_pipeline(
StandardScaler(),
DecisionTreeClassifier(random_state=1, criterion='entropy', max_depth=5, min_samples_split=2),
)
# Fit the model on training data
dtree_tuned1.fit(X_train, y_train)
Out[76]:
In [77]:
# Calculating different metrics
get_metrics_score(dtree_tuned1)
# Creating confusion matrix
make_confusion_matrix(y_test,dtree_tuned1)
Observations:
- The Tuned Decision tree Model (with Grid Search CV ) is not Overfitting and gives a good Accuracy.
- The Recall on test is 91.8% which is great.
DECISION TREE - Random Search CV¶
In [78]:
# Creating pipeline
pipe = make_pipeline(StandardScaler(), DecisionTreeClassifier(class_weight={0:0.45,1:0.55},random_state=1))
# Parameter grid to pass in GridSearchCV
param_grid = {
"decisiontreeclassifier__criterion": ['gini','entropy'],
"decisiontreeclassifier__max_depth": [3, 4, 5, None],
"decisiontreeclassifier__min_samples_split": [2,4,7,10,15]
}
# Type of scoring used to compare parameter combinations
scorer = metrics.make_scorer(metrics.recall_score)
#Calling RandomizedSearchCV
randomized_cv = RandomizedSearchCV(estimator=pipe, param_distributions=param_grid, n_iter=20, scoring=scorer, cv=5, random_state=1)
#Fitting parameters in RandomizedSearchCV
randomized_cv.fit(X_train,y_train)
print("Best parameters are {} with CV score={}:" .format(randomized_cv.best_params_,randomized_cv.best_score_))
In [79]:
# Creating new pipeline with best parameters
dtree_tuned2 = make_pipeline(
StandardScaler(),
DecisionTreeClassifier(random_state=1, criterion='entropy', max_depth=5, min_samples_split=4),
)
# Fit the model on training data
dtree_tuned2.fit(X_train, y_train)
Out[79]:
In [80]:
# Calculating different metrics
get_metrics_score(dtree_tuned2)
# Creating confusion matrix
make_confusion_matrix(y_test,dtree_tuned2)
Observations:
- The Tuned Decision tree Model (with Random Search CV ) is not Overfitting and gives a good Accuracy.
- The Recall on test is 91.8% which is great.
RANDOM FOREST - Grid Search CV¶
In [82]:
# Creating pipeline
pipe = make_pipeline(StandardScaler(), RandomForestClassifier(class_weight={0:0.45,1:0.55},random_state=1))
# Parameter grid to pass in GridSearchCV
param_grid = {
"randomforestclassifier__n_estimators": [100],
"randomforestclassifier__bootstrap": [True],
"randomforestclassifier__max_depth": [3, 5, 7],
"randomforestclassifier__max_features": ['auto', 'sqrt','log2'],
"randomforestclassifier__min_samples_leaf": [2, 3, 5],
"randomforestclassifier__min_samples_split": [3, 5, 7]
}
# Type of scoring used to compare parameter combinations
scorer = metrics.make_scorer(metrics.recall_score)
# Calling GridSearchCV
grid_cv = GridSearchCV(estimator=pipe, param_grid=param_grid, scoring=scorer, cv=3)
# Fitting parameters in GridSeachCV
grid_cv.fit(X_train, y_train)
print(
"Best Parameters:{} \nScore: {}".format(grid_cv.best_params_, grid_cv.best_score_)
)
In [83]:
# Creating new pipeline with best parameters
RF_tuned1 = make_pipeline(
StandardScaler(),
RandomForestClassifier(random_state=1,class_weight={0:0.45,1:0.55},max_features='auto',n_estimators=100,min_samples_leaf=2,bootstrap=True, max_depth=7, min_samples_split=7),
)
# Fit the model on training data
RF_tuned1.fit(X_train, y_train)
Out[83]:
In [84]:
# Calculating different metrics
get_metrics_score(RF_tuned1)
# Creating confusion matrix
make_confusion_matrix(y_test,RF_tuned1)
Observation
- The Random Forest Model (with Grid Search CV ) is not Overfitting and gives great Accuracy.
- The Recall on test is 93.8% which is great.
RANDOM FOREST - Random Search CV¶
In [85]:
# Creating pipeline
pipe = make_pipeline(StandardScaler(),RandomForestClassifier(class_weight={0:0.45,1:0.55},random_state=1))
# Parameter grid to pass in GridSearchCV
param_grid = {
"randomforestclassifier__n_estimators": [100],
"randomforestclassifier__bootstrap": [True],
"randomforestclassifier__max_depth": [3, 5, 7],
"randomforestclassifier__max_features": ['auto', 'sqrt','log2'],
"randomforestclassifier__min_samples_leaf": [2, 3, 5],
"randomforestclassifier__min_samples_split": [3, 5, 7]
}
# Type of scoring used to compare parameter combinations
scorer = metrics.make_scorer(metrics.recall_score)
#Calling RandomizedSearchCV
randomized_cv = RandomizedSearchCV(estimator=pipe, param_distributions=param_grid, n_iter=20, scoring=scorer, cv=5, random_state=1)
#Fitting parameters in RandomizedSearchCV
randomized_cv.fit(X_train,y_train)
print("Best parameters are {} with CV score={}:" .format(randomized_cv.best_params_,randomized_cv.best_score_))
In [86]:
# Creating new pipeline with best parameters
RF_tuned2 = make_pipeline(
StandardScaler(),
RandomForestClassifier(random_state=1,class_weight={0:0.45,1:0.55},bootstrap=True,n_estimators=100,min_samples_leaf=5,max_features='sqrt',max_depth=7, min_samples_split=3),
)
# Fit the model on training data
RF_tuned2.fit(X_train, y_train)
Out[86]:
In [87]:
# Calculating different metrics
get_metrics_score(RF_tuned2)
# Creating confusion matrix
make_confusion_matrix( y_test, RF_tuned2)
Observation
- The Random Forest Model (with Random Search CV ) is not Overfitting and gives great Accuracy.
- The Recall on test is 93.8% which is great.
ADA BOOST - Grid Search CV¶
In [89]:
# Creating pipeline
pipe = make_pipeline(
StandardScaler(), AdaBoostClassifier(random_state=1)
)
# Parameter grid to pass in GridSearchCV
param_grid = {
"adaboostclassifier__base_estimator":[DecisionTreeClassifier(max_depth=4)],
"adaboostclassifier__n_estimators": np.arange(10,110,10),
"adaboostclassifier__learning_rate":np.arange(0.1,1,0.1)
}
# Type of scoring used to compare parameter combinations
scorer = metrics.make_scorer(metrics.recall_score)
# Calling GridSearchCV
grid_cv = GridSearchCV(estimator=pipe, param_grid=param_grid, scoring=scorer, cv=3)
# Fitting parameters in GridSeachCV
grid_cv.fit(X_train, y_train)
print(
"Best parameters are {} with CV score={}:".format(
grid_cv.best_params_, grid_cv.best_score_
)
)
In [90]:
# Creating new pipeline with best parameters
Adb_tuned1 = make_pipeline(
StandardScaler(),
AdaBoostClassifier(random_state=1,n_estimators=70,learning_rate=0.6,base_estimator=DecisionTreeClassifier(max_depth=4)),
)
# Fit the model on training data
Adb_tuned1.fit(X_train, y_train)
Out[90]:
In [91]:
# Calculating different metrics
get_metrics_score(Adb_tuned1)
# Creating confusion matrix
make_confusion_matrix(y_test,Adb_tuned1)
Observation
- ADA BOOST (with GRID Search CV ) is not Overfitting and gives great Accuracy.
- The Recall on test is 94.2% which is great.
ADA -BOOST Random Search CV¶
In [92]:
# Creating pipeline
pipe = make_pipeline(StandardScaler(),AdaBoostClassifier(random_state=1))
# Parameter grid to pass in GridSearchCV
param_grid = {
"adaboostclassifier__base_estimator":[DecisionTreeClassifier(max_depth=4)],
"adaboostclassifier__n_estimators": np.arange(10,110,10),
"adaboostclassifier__learning_rate":np.arange(0.1,1,0.1)
}
# Type of scoring used to compare parameter combinations
scorer = metrics.make_scorer(metrics.recall_score)
#Calling RandomizedSearchCV
randomized_cv = RandomizedSearchCV(estimator=pipe, param_distributions=param_grid, n_iter=10, scoring=scorer, cv=3, random_state=1)
#Fitting parameters in RandomizedSearchCV
randomized_cv.fit(X_train,y_train)
print("Best parameters are {} with CV score={}:" .format(randomized_cv.best_params_,randomized_cv.best_score_))
In [93]:
# Creating new pipeline with best parameters
Adb_tuned2 = make_pipeline(
StandardScaler(),
AdaBoostClassifier(random_state=1,n_estimators=100,learning_rate=0.4,base_estimator=DecisionTreeClassifier(max_depth=4)),
)
# Fit the model on training data
Adb_tuned2.fit(X_train, y_train)
Out[93]:
In [94]:
# Calculating different metrics
get_metrics_score(Adb_tuned2)
# Creating confusion matrix
make_confusion_matrix(y_test, Adb_tuned2)
Observation
- ADA BOOST (with Randomized Search CV ) is not Overfitting and gives great Accuracy.
- The Recall on test is 94% which is great. This Model is able to generalize well on unseen data.
GRADIENT BOOST - Grid Search CV¶
In [95]:
# Creating pipeline
pipe = make_pipeline(
StandardScaler(), GradientBoostingClassifier(init=AdaBoostClassifier(random_state=1),random_state=1)
)
# Parameter grid to pass in GridSearchCV
param_grid = {
"gradientboostingclassifier__n_estimators": [100,150],
"gradientboostingclassifier__subsample":[0.8,0.9,1],
"gradientboostingclassifier__max_features":[0.7,0.8,0.9,1]
}
# Type of scoring used to compare parameter combinations
scorer = metrics.make_scorer(metrics.recall_score)
# Calling GridSearchCV
grid_cv = GridSearchCV(estimator=pipe, param_grid=param_grid, scoring=scorer, cv=3)
# Fitting parameters in GridSeachCV
grid_cv.fit(X_train, y_train)
print(
"Best parameters are {} with CV score={}:".format(
grid_cv.best_params_, grid_cv.best_score_
)
)
In [96]:
# Creating new pipeline with best parameters
Gmb_tuned1 = make_pipeline(
StandardScaler(),GradientBoostingClassifier(random_state=1,n_estimators=150,max_features=0.8,subsample=0.8),
)
# Fit the model on training data
Gmb_tuned1.fit(X_train, y_train)
Out[96]:
In [97]:
# Calculating different metrics
get_metrics_score(Gmb_tuned1)
# Creating confusion matrix
make_confusion_matrix(y_test,Gmb_tuned1)
Observation
- GRADIENT BOOST (with GRID Search CV ) is not Overfitting and gives great Accuracy.
- The Recall on test is 92.6% which is great. This Model is able to generalize well on unseen data.
Gradient Boost - Random Search CV¶
In [98]:
# Creating pipeline
pipe = make_pipeline(
StandardScaler(), GradientBoostingClassifier(init=AdaBoostClassifier(random_state=1),random_state=1)
)
# Parameter grid to pass in GridSearchCV
param_grid = {
"gradientboostingclassifier__n_estimators": [100,150],
"gradientboostingclassifier__subsample":[0.8,0.9,1],
"gradientboostingclassifier__max_features":[0.7,0.8,0.9,1]
}
# Type of scoring used to compare parameter combinations
scorer = metrics.make_scorer(metrics.recall_score)
#Calling RandomizedSearchCV
randomized_cv = RandomizedSearchCV(estimator=pipe, param_distributions=param_grid, n_iter=10, scoring=scorer, cv=3, random_state=1)
#Fitting parameters in RandomizedSearchCV
randomized_cv.fit(X_train,y_train)
print("Best parameters are {} with CV score={}:" .format(randomized_cv.best_params_,randomized_cv.best_score_))
In [99]:
# Creating new pipeline with best parameters
Gmb_tuned2 = make_pipeline(
StandardScaler(),GradientBoostingClassifier(random_state=1,n_estimators=150,max_features=0.8,subsample=0.9),
)
# Fit the model on training data
Gmb_tuned2.fit(X_train, y_train)
Out[99]:
In [100]:
# Calculating different metrics
get_metrics_score(Gmb_tuned2)
# Creating confusion matrix
make_confusion_matrix(y_test,Gmb_tuned2)
Observation
- GRADIENT BOOST (with Random Search CV ) is not Overfitting and gives great Accuracy.
- The Recall on test is 92.6% which is great. This Model is able to generalize well on unseen data.
XG- BOOST - GRID Seach CV¶
In [101]:
# Creating pipeline
pipe = make_pipeline(
StandardScaler(), XGBClassifier(random_state=1, eval_metric="logloss")
)
# Parameter grid to pass in GridSearchCV
param_grid = {
"xgbclassifier__n_estimators": np.arange(50, 100, 50),
"xgbclassifier__scale_pos_weight": [8],
"xgbclassifier__learning_rate": [0.01, 0.1, 0.2, 0.05],
"xgbclassifier__gamma": [0, 1, 3, 5],
"xgbclassifier__subsample": [0.7, 0.8, 0.9, 1],
}
# Type of scoring used to compare parameter combinations
scorer = metrics.make_scorer(metrics.recall_score)
# Calling GridSearchCV
grid_cv = GridSearchCV(estimator=pipe, param_grid=param_grid, scoring=scorer, cv=3)
# Fitting parameters in GridSeachCV
grid_cv.fit(X_train, y_train)
print(
"Best parameters are {} with CV score={}:".format(
grid_cv.best_params_, grid_cv.best_score_
)
)
In [102]:
# Creating new pipeline with best parameters
xgb_tuned1 = make_pipeline(
StandardScaler(),
XGBClassifier(
random_state=1,
eval_metric="logloss",
n_estimators=50,
scale_pos_weight=8,
subsample=1,
learning_rate=0.2,
gamma=5,
),
)
# Fit the model on training data
xgb_tuned1.fit(X_train, y_train)
Out[102]:
In [103]:
# Calculating different metrics
get_metrics_score(xgb_tuned1)
# Creating confusion matrix
make_confusion_matrix(y_test,xgb_tuned1)
Observation -XG Boost with Grid Search CV gave us an excellent Accuracy.
- The Recall Score we got from this Model is 98.9%
- This Model is able to generalize well on the unseen data.
XGB Tuned - Random Search CV¶
In [104]:
#Creating pipeline
pipe=make_pipeline(StandardScaler(),XGBClassifier(random_state=1,eval_metric="logloss"))
#Parameter grid to pass in GridSearchCV
param_grid={'xgbclassifier__n_estimators':np.arange(50,100,50),'xgbclassifier__scale_pos_weight':[8],
'xgbclassifier__learning_rate':[0.01,0.1,0.2,0.05], 'xgbclassifier__gamma':[0,1,3,5],
'xgbclassifier__subsample':[0.7,0.8,0.9,1]}
# Type of scoring used to compare parameter combinations
scorer = metrics.make_scorer(metrics.recall_score)
#Calling RandomizedSearchCV
randomized_cv = RandomizedSearchCV(estimator=pipe, param_distributions=param_grid, n_iter=10, scoring=scorer, cv=3, random_state=1)
#Fitting parameters in RandomizedSearchCV
randomized_cv.fit(X_train,y_train)
print("Best parameters are {} with CV score={}:" .format(randomized_cv.best_params_,randomized_cv.best_score_))
In [105]:
# Creating new pipeline with best parameters
xgb_tuned2 = Pipeline(
steps=[
("scaler", StandardScaler()),
(
"XGB",
XGBClassifier(
random_state=1,
eval_metric="logloss",
n_estimators=50,
scale_pos_weight=8,
learning_rate=0.2,
gamma=1,
subsample=1,
),
),
]
)
# Fit the model on training data
xgb_tuned2.fit(X_train, y_train)
Out[105]:
In [106]:
# Calculating different metrics
get_metrics_score(xgb_tuned2)
# Creating confusion matrix
make_confusion_matrix( y_test,xgb_tuned2)
Observation
- XG Boost with Random Search CV gave us an excellent Accuracy.
- The Recall Score we got from this Model is 99% This Model is able to generalize well on the unseen data.
MODEL COMPARISONS¶
In [129]:
import pandas as pd
comparison_frame = pd.DataFrame({'Model':['Initial Logistic Regression Model with sklearn', 'Increased optimal threshold - Logistic Regression Model with sklearn','Best optimal threshold - Logistic Regression Model with sklearn',
], 'Train_Accuracy':[0.79,0.79,0.79], 'Test_Accuracy':[0.79,0.79,0.79],'Train_Recall':[0.84,0.78,0.84],'Test_Recall':[0.84,0.78,0.83], 'Train_Precision':[0.79,0.83,0.79], 'Train_Accuracy':[0.79,0.82,0.79]
})
comparison_frame
Out[129]:
Observation
- Logistic Regession with Optimal Threshold has given quite a generalized performance .
- This Model gave us the Best Recall which is 84% and also there is no overfitting.
In [107]:
# defining list of models
models = [dtree_tuned1, dtree_tuned2, RF_tuned1, RF_tuned2, Adb_tuned1, Adb_tuned2, Gmb_tuned1, Gmb_tuned2, xgb_tuned1, xgb_tuned2]
# defining empty lists to add train and test results
acc_train = []
acc_test = []
recall_train = []
recall_test = []
precision_train = []
precision_test = []
# looping through all the models to get the metrics score - Accuracy, Recall and Precision
for model in models:
j = get_metrics_score(model, False)
acc_train.append(j[0])
acc_test.append(j[1])
recall_train.append(j[2])
recall_test.append(j[3])
precision_train.append(j[4])
precision_test.append(j[5])
In [108]:
comparison_frame = pd.DataFrame(
{
"Model": [
"Decision-Tree-GridSearchCV",
"Decision-Tree-RandomSearchCV",
"Random-Forest-GridSearchCV",
"Random-Forest-RandomSearchCV",
"ADA-Boost-GridSearchCV",
"ADA-Boost-RandomSearchCV",
"GMB-GridSearchCV",
"GMB-RandomSearchCV",
"XG-Boost-GridSearchCV",
"XG-Boost-RandomSearchCV",
],
"Train_Accuracy": acc_train,
"Test_Accuracy": acc_test,
"Train_Recall": recall_train,
"Test_Recall": recall_test,
"Train_Precision": precision_train,
"Test_Precision": precision_test,
}
)
# Sorting models in decreasing order of test recall
comparison_frame.sort_values(by="Test_Recall", ascending=False)
Out[108]:
Observation
- Hypertuned XG-Boost with Random Search CV has given us an extremely generalised Model
- The Recall we got from this Model is 99% .
- There is no overfitting and the Precision we got , is also great.
- So, this Model could be cosidered to be the best of all and will also generalize well on the unseen data.
- Hence , this Model can predict whether a passenger will be satisfied or not given the rest of the details are provided.
Interpretation From The Best Model¶
Feature Importance from : XGB - Random Search CV¶
In [128]:
feature_names = X_train.columns
importances = xgb_tuned2[1].feature_importances_
indices = np.argsort(importances)
my_colors = 'gggyyyyyybbbbbbggggggg'
plt.figure(figsize=(12, 12))
plt.title("Feature Importances")
plt.barh(range(len(indices)), importances[indices], color=my_colors, align="center")
plt.yticks(range(len(indices)), [feature_names[i] for i in indices])
plt.xlabel("Relative Importance")
plt.show()
Insights From the Best Model
- The Most Important Features according to the Best Model are :
- InFlight Entertainmnt ,Seat Comfort , Gender : Female ,Ease Of Online Banking and On-Board Service are the most significant variables which sway the Customers towards Satisfaction.
Partial Dependence Plots¶
While feature importance shows what variables most affect predictions, partial dependence plots show how a feature affects predictions.
- The y axis is interpreted as change in the prediction from what it would be predicted at the baseline or leftmost value.
- A blue shaded area indicates level of confidence
In [138]:
from pdpbox import pdp, get_dataset, info_plots
In [139]:
def plot_pdp(model, df, feature, cluster_flag=False, nb_clusters=None, lines_flag=False):
# Create the data that we will plot
pdp_goals = pdp.pdp_isolate(model=xgb_tuned2, dataset=X_train, model_features=X_train.columns.tolist(), feature=feature)
# plot it
pdp.pdp_plot(pdp_goals, feature, cluster=cluster_flag, n_cluster_centers=nb_clusters, plot_lines=lines_flag)
plt.show()
Influence of InFlight Entertainment on Satisfaction:¶
In [142]:
# plot the PD univariate plot
plot_pdp(xgb_tuned2, X_train, 'Inflght_entrtnmnt')
Observation
This PD plot show us that the Service InFlight Entertainment seems to have an increasing positive Impact on the Target variable : Satisfaction for values between 3 and 5.
- After that treshold the influence is still positive and increasing progressively, and before that it was neutral/very slightly negative.
Influence of Seat Comfort on Satisfaction:¶
In [147]:
# plot the PD univariate plot
plot_pdp(xgb_tuned2, X_train, 'Travel_Type_Business travel')
Observation
- For the Travel type : Business , we see that its a sharp upwards trend ,which means this variable has a strong positive effect on the Customers swaying towards Satisfied.
Influence of InFlight Entertainment on Gender Female:¶
In [145]:
# plot the PD univariate plot
plot_pdp(xgb_tuned2, X_train, 'Gender_Female')
Observation
- This category has a Positive influence on the Response variable.
Influence of Gender : Male on Satisfaction:¶¶
In [144]:
# plot the PD univariate plot
plot_pdp(xgb_tuned2, X_train, 'Gender_Male')
Observation
- Its significant that the Variable (Gender : Male) does not have any Influence on the Target.
We analyzed the "Falcon Airlines Customer data" using different Analysis techniques like Logistic Regression ,Ensemble Modelling methods like Bagging and Boosting , Hypertuned Models, in order to build a model to predict if a customer is likely to be swayed towards Satisfaction or Not.
All of the Models built, were evaluated for the best results in terms of our Scoring metrics which was RECALL.
We compared these Models to check which one gave us the best possible Recall score , that was our main Model Evaluation Criteria.
We build the Model keeping in mind the Model evaluation criterion - The True Positive Rates - where we tried to improve the proportions of correctly identified probabilities of yes . Hence , the Model with the best Recall and the one which would generalize well , was chosen to be the final best Model.
With the Logistic Regression Analysis , the Model with Optimal Threshold has given a generalized performance with a Test Recall of 84%.
There was still scope for improvement , so we went ahead with further analysis and tried different Models.
Hypertuned XG-Boost with Randomized Search CV has given us an extremely generalised Model. The Recall we got from this Model is 99% .There is no overfitting .So, this Model could be cosidered to be the best of all and will also generalize well.
With Tuned XG-Boost with Randomized Search CVthe features that were deemed most significant are : InFlight Entertainmnt ,Seat Comfort , Gender : Female , Ease Of Online Banking and On-Board Service are the most significant
Business Insights :¶
The Air transportation industry is becoming leaner, quicker, tech-enabled, and data-driven.
Machine learning methods have transformed our ability to improve interactions for customers (who look for information, solutions, or resolution through personalized experiences) and organizations(who look to provide those personalized experiences across multiple channels in the most cost-efficient manner).
- InFlight Entertainment has emerged to be as the most significant feature propelling a Customer towards Satisfaction.
- Passengers are far more likely to have a positive experience with an airline if they are entertained during their flight. The Airlines could very well look out for more innovative strategies to keep the Passengers entertained and increase the company's ability to wow and exceed Customer expectations.
- The second most significant feature being Seat Comfort. Comfort is becoming an important issue that airlines use to differentiate themselves in a competitive market.Passengers look for a Personal space even when they are on a Flight. Improved Seat design and better comfort could help make the whole journey worthwhile.
- Ease Of Online Booking being another important feature. One advantage of booking a Flight online is the convenience. Customers on the go can even make reservations on their smartphones or tablets.The Airlines could design personalised Flight booking experience fueling the increase in customer satisfaction
- On-Board Service also plays a significant Role for Passenger Satisfaction. Providing a service that is perfectly tailored to a Passenger's needs in all travel classes. This way the Airlines Airlines could generate long-term loyalty from customers.
- Travel Type : Business : Business travelers account for 12% percent of airlines' passengers, but they are typically twice as lucrative – accounting for as much as 75% of profits. Seems like this class has little or no complaints at all.
- On the other hand if we look at the least significant features or Services : The Airlines could work on improving their Baggage Handling performance, so as to improve on the Ratings.
- Cleanliness has not emerged significant either. Need for a clean environment has become important during air travel. dimensions like food & flight attendants and lavatory to be given special focus for sanity.
- Airlines could focus on upping their game in economy Class as well.Enhancements in the Seats, mood lighting in the cabin and cappuccinos on the Meal Troley could be a game changer.
- As far as Food and Drink is concerned, the Airlines could focus its efforts on the in-flight dining experience, increasing the choice of meal options available, with new categories including a healthy option, comfort food and a meal inspired by the route itself.
- In-Flight WiFi Service : “Always on” is no longer a luxury. Fr most people, being connected is a requirement, even when flying 30,000 feet above the ground. And for parents towing a child, it is a life-saver. Passengers could these days even consider in-flight connectivity to be more important than in-flight entertainment.So, it would be a great idea to work on providing high-quality in-flight connectivity to the Passengers.
Introducing things like Well-being on board whee the passengers will receive practical tips and tricks for their well-being during flight in a sporty video with celebrity support , would enhance their Flight experience.Airlines could work closely with their Customers to continuously develop and install new features and elements into a cabin, inrder to improve the overall Flight Experience.Hence, the Airlines can map out how each customer journey can be re-designed to reflect the values driving the Airline's purpose and also sway more Customers towards Satisfaction.
In [ ]:
In [ ]: